haraldwolff/qemu-patch-raspberry4
1
0
Fork 0
Code Issues Pull requests Packages Projects Releases Wiki Activity

kvm: Free current_cpu identifier

Browse source 
Since CPU loops are done as last step in kvm_{insert,remove}_breakpoint()
and kvm_remove_all_breakpoints(), we do not need to distinguish between
invoking CPU and iterated CPUs and can thereby free the identifier for
use as a global variable.

Acked-by: Paolo Bonzini <pbonzini@redhat.com>
Signed-off-by: Andreas Färber <afaerber@suse.de>
This commit is contained in:
Andreas Färber 2013-06-19 17:37:31 +02:00
parent 6e42be7cd1
commit 80b7cd7354
3 changed files with 25 additions and 30 deletions
Show stats Download patch file Download diff file Expand all files Collapse all files

10
include/sysemu/kvm.h
View file

@ -169,11 +169,11 @@ void *kvm_arch_ram_alloc(ram_addr_t size);
void kvm_setup_guest_memory(void *start, size_t size); void kvm_setup_guest_memory(void *start, size_t size);
void kvm_flush_coalesced_mmio_buffer(void); void kvm_flush_coalesced_mmio_buffer(void);
int kvm_insert_breakpoint(CPUArchState *current_env, target_ulong addr, int kvm_insert_breakpoint(CPUArchState *env, target_ulong addr,
target_ulong len, int type); target_ulong len, int type);
int kvm_remove_breakpoint(CPUArchState *current_env, target_ulong addr, int kvm_remove_breakpoint(CPUArchState *env, target_ulong addr,
target_ulong len, int type); target_ulong len, int type);
void kvm_remove_all_breakpoints(CPUArchState *current_env); void kvm_remove_all_breakpoints(CPUArchState *env);
int kvm_update_guest_debug(CPUArchState *env, unsigned long reinject_trap); int kvm_update_guest_debug(CPUArchState *env, unsigned long reinject_trap);
#ifndef _WIN32 #ifndef _WIN32
int kvm_set_signal_mask(CPUState *cpu, const sigset_t *sigset); int kvm_set_signal_mask(CPUState *cpu, const sigset_t *sigset);
@ -252,9 +252,9 @@ struct kvm_sw_breakpoint *kvm_find_sw_breakpoint(CPUState *cpu,
int kvm_sw_breakpoints_active(CPUState *cpu); int kvm_sw_breakpoints_active(CPUState *cpu);
int kvm_arch_insert_sw_breakpoint(CPUState *current_cpu, int kvm_arch_insert_sw_breakpoint(CPUState *cpu,
struct kvm_sw_breakpoint *bp); struct kvm_sw_breakpoint *bp);
int kvm_arch_remove_sw_breakpoint(CPUState *current_cpu, int kvm_arch_remove_sw_breakpoint(CPUState *cpu,
struct kvm_sw_breakpoint *bp); struct kvm_sw_breakpoint *bp);
int kvm_arch_insert_hw_breakpoint(target_ulong addr, int kvm_arch_insert_hw_breakpoint(target_ulong addr,
target_ulong len, int type); target_ulong len, int type);

39
kvm-all.c
View file

@ -1903,16 +1903,15 @@ int kvm_update_guest_debug(CPUArchState *env, unsigned long reinject_trap)
return data.err; return data.err;
} }
int kvm_insert_breakpoint(CPUArchState *current_env, target_ulong addr, int kvm_insert_breakpoint(CPUArchState *env, target_ulong addr,
target_ulong len, int type) target_ulong len, int type)
{ {
CPUState *current_cpu = ENV_GET_CPU(current_env); CPUState *cpu = ENV_GET_CPU(env);
struct kvm_sw_breakpoint *bp; struct kvm_sw_breakpoint *bp;
CPUArchState *env;
int err; int err;
if (type == GDB_BREAKPOINT_SW) { if (type == GDB_BREAKPOINT_SW) {
bp = kvm_find_sw_breakpoint(current_cpu, addr); bp = kvm_find_sw_breakpoint(cpu, addr);
if (bp) { if (bp) {
bp->use_count++; bp->use_count++;
return 0; return 0;
@ -1925,14 +1924,13 @@ int kvm_insert_breakpoint(CPUArchState *current_env, target_ulong addr,
bp->pc = addr; bp->pc = addr;
bp->use_count = 1; bp->use_count = 1;
err = kvm_arch_insert_sw_breakpoint(current_cpu, bp); err = kvm_arch_insert_sw_breakpoint(cpu, bp);
if (err) { if (err) {
g_free(bp); g_free(bp);
return err; return err;
} }
QTAILQ_INSERT_HEAD(&current_cpu->kvm_state->kvm_sw_breakpoints, QTAILQ_INSERT_HEAD(&cpu->kvm_state->kvm_sw_breakpoints, bp, entry);
bp, entry);
} else { } else {
err = kvm_arch_insert_hw_breakpoint(addr, len, type); err = kvm_arch_insert_hw_breakpoint(addr, len, type);
if (err) { if (err) {
@ -1949,16 +1947,15 @@ int kvm_insert_breakpoint(CPUArchState *current_env, target_ulong addr,
return 0; return 0;
} }
int kvm_remove_breakpoint(CPUArchState *current_env, target_ulong addr, int kvm_remove_breakpoint(CPUArchState *env, target_ulong addr,
target_ulong len, int type) target_ulong len, int type)
{ {
CPUState *current_cpu = ENV_GET_CPU(current_env); CPUState *cpu = ENV_GET_CPU(env);
struct kvm_sw_breakpoint *bp; struct kvm_sw_breakpoint *bp;
CPUArchState *env;
int err; int err;
if (type == GDB_BREAKPOINT_SW) { if (type == GDB_BREAKPOINT_SW) {
bp = kvm_find_sw_breakpoint(current_cpu, addr); bp = kvm_find_sw_breakpoint(cpu, addr);
if (!bp) { if (!bp) {
return -ENOENT; return -ENOENT;
} }
@ -1968,12 +1965,12 @@ int kvm_remove_breakpoint(CPUArchState *current_env, target_ulong addr,
return 0; return 0;
} }
err = kvm_arch_remove_sw_breakpoint(current_cpu, bp); err = kvm_arch_remove_sw_breakpoint(cpu, bp);
if (err) { if (err) {
return err; return err;
} }
QTAILQ_REMOVE(&current_cpu->kvm_state->kvm_sw_breakpoints, bp, entry); QTAILQ_REMOVE(&cpu->kvm_state->kvm_sw_breakpoints, bp, entry);
g_free(bp); g_free(bp);
} else { } else {
err = kvm_arch_remove_hw_breakpoint(addr, len, type); err = kvm_arch_remove_hw_breakpoint(addr, len, type);
@ -1991,16 +1988,14 @@ int kvm_remove_breakpoint(CPUArchState *current_env, target_ulong addr,
return 0; return 0;
} }
void kvm_remove_all_breakpoints(CPUArchState *current_env) void kvm_remove_all_breakpoints(CPUArchState *env)
{ {
CPUState *current_cpu = ENV_GET_CPU(current_env); CPUState *cpu = ENV_GET_CPU(env);
struct kvm_sw_breakpoint *bp, *next; struct kvm_sw_breakpoint *bp, *next;
KVMState *s = current_cpu->kvm_state; KVMState *s = cpu->kvm_state;
CPUArchState *env;
CPUState *cpu;
QTAILQ_FOREACH_SAFE(bp, &s->kvm_sw_breakpoints, entry, next) { QTAILQ_FOREACH_SAFE(bp, &s->kvm_sw_breakpoints, entry, next) {
if (kvm_arch_remove_sw_breakpoint(current_cpu, bp) != 0) { if (kvm_arch_remove_sw_breakpoint(cpu, bp) != 0) {
/* Try harder to find a CPU that currently sees the breakpoint. */ /* Try harder to find a CPU that currently sees the breakpoint. */
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);
@ -2026,19 +2021,19 @@ int kvm_update_guest_debug(CPUArchState *env, unsigned long reinject_trap)
return -EINVAL; return -EINVAL;
} }
int kvm_insert_breakpoint(CPUArchState *current_env, target_ulong addr, int kvm_insert_breakpoint(CPUArchState *env, target_ulong addr,
target_ulong len, int type) target_ulong len, int type)
{ {
return -EINVAL; return -EINVAL;
} }
int kvm_remove_breakpoint(CPUArchState *current_env, target_ulong addr, int kvm_remove_breakpoint(CPUArchState *env, target_ulong addr,
target_ulong len, int type) target_ulong len, int type)
{ {
return -EINVAL; return -EINVAL;
} }
void kvm_remove_all_breakpoints(CPUArchState *current_env) void kvm_remove_all_breakpoints(CPUArchState *env)
{ {
} }
#endif /* !KVM_CAP_SET_GUEST_DEBUG */ #endif /* !KVM_CAP_SET_GUEST_DEBUG */

6
kvm-stub.c
View file

@ -83,19 +83,19 @@ int kvm_update_guest_debug(CPUArchState *env, unsigned long reinject_trap)
return -ENOSYS; return -ENOSYS;
} }
int kvm_insert_breakpoint(CPUArchState *current_env, target_ulong addr, int kvm_insert_breakpoint(CPUArchState *env, target_ulong addr,
target_ulong len, int type) target_ulong len, int type)
{ {
return -EINVAL; return -EINVAL;
} }
int kvm_remove_breakpoint(CPUArchState *current_env, target_ulong addr, int kvm_remove_breakpoint(CPUArchState *env, target_ulong addr,
target_ulong len, int type) target_ulong len, int type)
{ {
return -EINVAL; return -EINVAL;
} }
void kvm_remove_all_breakpoints(CPUArchState *current_env) void kvm_remove_all_breakpoints(CPUArchState *env)
{ {
} }