* [PATCH 1/4] qemu-kvm-x86.c: reindent
2010-09-05 12:13 [PATCH 0/4] Apply some CODING_STYLE to qemu-kvm*.c Avi Kivity
@ 2010-09-05 12:13 ` Avi Kivity
2010-09-05 12:13 ` [PATCH 2/4] qemu-kvm-x86.c: remove extraneous line continuation Avi Kivity
` (4 subsequent siblings)
5 siblings, 0 replies; 7+ messages in thread
From: Avi Kivity @ 2010-09-05 12:13 UTC (permalink / raw)
To: Marcelo Tosatti, kvm
Reindent qemu-kvm-x86.c according to CODING_STYLE. The original used a mix
of qemu and linux indentation styles.
Signed-off-by: Avi Kivity <avi@redhat.com>
---
qemu-kvm-x86.c | 800 ++++++++++++++++++++++++++++----------------------------
1 files changed, 398 insertions(+), 402 deletions(-)
diff --git a/qemu-kvm-x86.c b/qemu-kvm-x86.c
index 4c32771..f2c81f0 100644
--- a/qemu-kvm-x86.c
+++ b/qemu-kvm-x86.c
@@ -24,7 +24,7 @@
#include "kvm.h"
#include "hw/apic.h"
-#define MSR_IA32_TSC 0x10
+#define MSR_IA32_TSC 0x10
static struct kvm_msr_list *kvm_msr_list;
extern unsigned int kvm_shadow_memory;
@@ -35,205 +35,203 @@ static int lm_capable_kernel;
int kvm_set_tss_addr(kvm_context_t kvm, unsigned long addr)
{
- int r;
- /*
- * Tell fw_cfg to notify the BIOS to reserve the range.
- */
- if (e820_add_entry(addr, 0x4000, E820_RESERVED) < 0) {
- perror("e820_add_entry() table is full");
- exit(1);
- }
+ int r;
+ /*
+ * Tell fw_cfg to notify the BIOS to reserve the range.
+ */
+ if (e820_add_entry(addr, 0x4000, E820_RESERVED) < 0) {
+ perror("e820_add_entry() table is full");
+ exit(1);
+ }
- r = kvm_vm_ioctl(kvm_state, KVM_SET_TSS_ADDR, addr);
- if (r < 0) {
- fprintf(stderr, "kvm_set_tss_addr: %m\n");
- return r;
- }
- return 0;
+ r = kvm_vm_ioctl(kvm_state, KVM_SET_TSS_ADDR, addr);
+ if (r < 0) {
+ fprintf(stderr, "kvm_set_tss_addr: %m\n");
+ return r;
+ }
+ return 0;
}
static int kvm_init_tss(kvm_context_t kvm)
{
- int r;
-
- r = kvm_ioctl(kvm_state, KVM_CHECK_EXTENSION, KVM_CAP_SET_TSS_ADDR);
- if (r > 0) {
- /*
- * this address is 3 pages before the bios, and the bios should present
- * as unavaible memory
- */
- r = kvm_set_tss_addr(kvm, 0xfeffd000);
- if (r < 0) {
- fprintf(stderr, "kvm_init_tss: unable to set tss addr\n");
- return r;
- }
- } else {
- fprintf(stderr, "kvm does not support KVM_CAP_SET_TSS_ADDR\n");
- }
- return 0;
+ int r;
+
+ r = kvm_ioctl(kvm_state, KVM_CHECK_EXTENSION, KVM_CAP_SET_TSS_ADDR);
+ if (r > 0) {
+ /*
+ * this address is 3 pages before the bios, and the bios should present
+ * as unavaible memory
+ */
+ r = kvm_set_tss_addr(kvm, 0xfeffd000);
+ if (r < 0) {
+ fprintf(stderr, "kvm_init_tss: unable to set tss addr\n");
+ return r;
+ }
+ } else {
+ fprintf(stderr, "kvm does not support KVM_CAP_SET_TSS_ADDR\n");
+ }
+ return 0;
}
static int kvm_set_identity_map_addr(kvm_context_t kvm, uint64_t addr)
{
#ifdef KVM_CAP_SET_IDENTITY_MAP_ADDR
- int r;
-
- r = kvm_ioctl(kvm_state, KVM_CHECK_EXTENSION, KVM_CAP_SET_IDENTITY_MAP_ADDR);
- if (r > 0) {
- r = kvm_vm_ioctl(kvm_state, KVM_SET_IDENTITY_MAP_ADDR, &addr);
- if (r == -1) {
- fprintf(stderr, "kvm_set_identity_map_addr: %m\n");
- return -errno;
- }
- return 0;
- }
+ int r;
+
+ r = kvm_ioctl(kvm_state, KVM_CHECK_EXTENSION, KVM_CAP_SET_IDENTITY_MAP_ADDR);
+ if (r > 0) {
+ r = kvm_vm_ioctl(kvm_state, KVM_SET_IDENTITY_MAP_ADDR, &addr);
+ if (r == -1) {
+ fprintf(stderr, "kvm_set_identity_map_addr: %m\n");
+ return -errno;
+ }
+ return 0;
+ }
#endif
- return -ENOSYS;
+ return -ENOSYS;
}
static int kvm_init_identity_map_page(kvm_context_t kvm)
{
#ifdef KVM_CAP_SET_IDENTITY_MAP_ADDR
- int r;
-
- r = kvm_ioctl(kvm_state, KVM_CHECK_EXTENSION, KVM_CAP_SET_IDENTITY_MAP_ADDR);
- if (r > 0) {
- /*
- * this address is 4 pages before the bios, and the bios should present
- * as unavaible memory
- */
- r = kvm_set_identity_map_addr(kvm, 0xfeffc000);
- if (r < 0) {
- fprintf(stderr, "kvm_init_identity_map_page: "
- "unable to set identity mapping addr\n");
- return r;
- }
-
- }
+ int r;
+
+ r = kvm_ioctl(kvm_state, KVM_CHECK_EXTENSION, KVM_CAP_SET_IDENTITY_MAP_ADDR);
+ if (r > 0) {
+ /*
+ * this address is 4 pages before the bios, and the bios should present
+ * as unavaible memory
+ */
+ r = kvm_set_identity_map_addr(kvm, 0xfeffc000);
+ if (r < 0) {
+ fprintf(stderr, "kvm_init_identity_map_page: "
+ "unable to set identity mapping addr\n");
+ return r;
+ }
+ }
#endif
- return 0;
+ return 0;
}
static int kvm_create_pit(kvm_context_t kvm)
{
#ifdef KVM_CAP_PIT
- int r;
-
- kvm_state->pit_in_kernel = 0;
- if (!kvm->no_pit_creation) {
- r = kvm_ioctl(kvm_state, KVM_CHECK_EXTENSION, KVM_CAP_PIT);
- if (r > 0) {
- r = kvm_vm_ioctl(kvm_state, KVM_CREATE_PIT);
- if (r >= 0)
- kvm_state->pit_in_kernel = 1;
- else {
- fprintf(stderr, "Create kernel PIC irqchip failed\n");
- return r;
- }
- }
- }
+ int r;
+
+ kvm_state->pit_in_kernel = 0;
+ if (!kvm->no_pit_creation) {
+ r = kvm_ioctl(kvm_state, KVM_CHECK_EXTENSION, KVM_CAP_PIT);
+ if (r > 0) {
+ r = kvm_vm_ioctl(kvm_state, KVM_CREATE_PIT);
+ if (r >= 0)
+ kvm_state->pit_in_kernel = 1;
+ else {
+ fprintf(stderr, "Create kernel PIC irqchip failed\n");
+ return r;
+ }
+ }
+ }
#endif
- return 0;
+ return 0;
}
int kvm_arch_create(kvm_context_t kvm, unsigned long phys_mem_bytes,
- void **vm_mem)
+ void **vm_mem)
{
- int r = 0;
+ int r = 0;
- r = kvm_init_tss(kvm);
- if (r < 0)
- return r;
+ r = kvm_init_tss(kvm);
+ if (r < 0)
+ return r;
- r = kvm_init_identity_map_page(kvm);
- if (r < 0)
- return r;
+ r = kvm_init_identity_map_page(kvm);
+ if (r < 0)
+ return r;
- r = kvm_create_pit(kvm);
- if (r < 0)
- return r;
+ r = kvm_create_pit(kvm);
+ if (r < 0)
+ return r;
- r = kvm_init_coalesced_mmio(kvm);
- if (r < 0)
- return r;
+ r = kvm_init_coalesced_mmio(kvm);
+ if (r < 0)
+ return r;
- return 0;
+ return 0;
}
#ifdef KVM_EXIT_TPR_ACCESS
static int kvm_handle_tpr_access(CPUState *env)
{
- struct kvm_run *run = env->kvm_run;
- kvm_tpr_access_report(env,
- run->tpr_access.rip,
- run->tpr_access.is_write);
+ struct kvm_run *run = env->kvm_run;
+ kvm_tpr_access_report(env,
+ run->tpr_access.rip,
+ run->tpr_access.is_write);
return 0;
}
int kvm_enable_vapic(CPUState *env, uint64_t vapic)
{
- struct kvm_vapic_addr va = {
- .vapic_addr = vapic,
- };
+ struct kvm_vapic_addr va = {
+ .vapic_addr = vapic,
+ };
- return kvm_vcpu_ioctl(env, KVM_SET_VAPIC_ADDR, &va);
+ return kvm_vcpu_ioctl(env, KVM_SET_VAPIC_ADDR, &va);
}
#endif
int kvm_arch_run(CPUState *env)
{
- int r = 0;
- struct kvm_run *run = env->kvm_run;
-
+ int r = 0;
+ struct kvm_run *run = env->kvm_run;
- switch (run->exit_reason) {
+ switch (run->exit_reason) {
#ifdef KVM_EXIT_SET_TPR
- case KVM_EXIT_SET_TPR:
- break;
+ case KVM_EXIT_SET_TPR:
+ break;
#endif
#ifdef KVM_EXIT_TPR_ACCESS
- case KVM_EXIT_TPR_ACCESS:
- r = kvm_handle_tpr_access(env);
- break;
+ case KVM_EXIT_TPR_ACCESS:
+ r = kvm_handle_tpr_access(env);
+ break;
#endif
- default:
- r = 1;
- break;
- }
+ default:
+ r = 1;
+ break;
+ }
- return r;
+ return r;
}
#ifdef KVM_CAP_IRQCHIP
int kvm_get_lapic(CPUState *env, struct kvm_lapic_state *s)
{
- int r = 0;
+ int r = 0;
- if (!kvm_irqchip_in_kernel())
- return r;
+ if (!kvm_irqchip_in_kernel())
+ return r;
- r = kvm_vcpu_ioctl(env, KVM_GET_LAPIC, s);
- if (r < 0)
- fprintf(stderr, "KVM_GET_LAPIC failed\n");
- return r;
+ r = kvm_vcpu_ioctl(env, KVM_GET_LAPIC, s);
+ if (r < 0)
+ fprintf(stderr, "KVM_GET_LAPIC failed\n");
+ return r;
}
int kvm_set_lapic(CPUState *env, struct kvm_lapic_state *s)
{
- int r = 0;
+ int r = 0;
- if (!kvm_irqchip_in_kernel())
- return 0;
+ if (!kvm_irqchip_in_kernel())
+ return 0;
- r = kvm_vcpu_ioctl(env, KVM_SET_LAPIC, s);
+ r = kvm_vcpu_ioctl(env, KVM_SET_LAPIC, s);
- if (r < 0)
- fprintf(stderr, "KVM_SET_LAPIC failed\n");
- return r;
+ if (r < 0)
+ fprintf(stderr, "KVM_SET_LAPIC failed\n");
+ return r;
}
#endif
@@ -242,31 +240,31 @@ int kvm_set_lapic(CPUState *env, struct kvm_lapic_state *s)
int kvm_get_pit(kvm_context_t kvm, struct kvm_pit_state *s)
{
- if (!kvm_pit_in_kernel())
- return 0;
- return kvm_vm_ioctl(kvm_state, KVM_GET_PIT, s);
+ if (!kvm_pit_in_kernel())
+ return 0;
+ return kvm_vm_ioctl(kvm_state, KVM_GET_PIT, s);
}
int kvm_set_pit(kvm_context_t kvm, struct kvm_pit_state *s)
{
- if (!kvm_pit_in_kernel())
- return 0;
- return kvm_vm_ioctl(kvm_state, KVM_SET_PIT, s);
+ if (!kvm_pit_in_kernel())
+ return 0;
+ return kvm_vm_ioctl(kvm_state, KVM_SET_PIT, s);
}
#ifdef KVM_CAP_PIT_STATE2
int kvm_get_pit2(kvm_context_t kvm, struct kvm_pit_state2 *ps2)
{
- if (!kvm_pit_in_kernel())
- return 0;
- return kvm_vm_ioctl(kvm_state, KVM_GET_PIT2, ps2);
+ if (!kvm_pit_in_kernel())
+ return 0;
+ return kvm_vm_ioctl(kvm_state, KVM_GET_PIT2, ps2);
}
int kvm_set_pit2(kvm_context_t kvm, struct kvm_pit_state2 *ps2)
{
- if (!kvm_pit_in_kernel())
- return 0;
- return kvm_vm_ioctl(kvm_state, KVM_SET_PIT2, ps2);
+ if (!kvm_pit_in_kernel())
+ return 0;
+ return kvm_vm_ioctl(kvm_state, KVM_SET_PIT2, ps2);
}
#endif
@@ -274,47 +272,47 @@ int kvm_set_pit2(kvm_context_t kvm, struct kvm_pit_state2 *ps2)
int kvm_has_pit_state2(kvm_context_t kvm)
{
- int r = 0;
+ int r = 0;
#ifdef KVM_CAP_PIT_STATE2
- r = kvm_check_extension(kvm_state, KVM_CAP_PIT_STATE2);
+ r = kvm_check_extension(kvm_state, KVM_CAP_PIT_STATE2);
#endif
- return r;
+ return r;
}
void kvm_show_code(CPUState *env)
{
#define SHOW_CODE_LEN 50
- struct kvm_regs regs;
- struct kvm_sregs sregs;
- int r, n;
- int back_offset;
- unsigned char code;
- char code_str[SHOW_CODE_LEN * 3 + 1];
- unsigned long rip;
-
- r = kvm_vcpu_ioctl(env, KVM_GET_SREGS, &sregs);
- if (r < 0 ) {
- perror("KVM_GET_SREGS");
- return;
- }
- r = kvm_vcpu_ioctl(env, KVM_GET_REGS, ®s);
- if (r < 0) {
- perror("KVM_GET_REGS");
- return;
- }
- rip = sregs.cs.base + regs.rip;
- back_offset = regs.rip;
- if (back_offset > 20)
- back_offset = 20;
- *code_str = 0;
- for (n = -back_offset; n < SHOW_CODE_LEN-back_offset; ++n) {
- if (n == 0)
- strcat(code_str, " -->");
- cpu_physical_memory_rw(rip + n, &code, 1, 1);
- sprintf(code_str + strlen(code_str), " %02x", code);
- }
- fprintf(stderr, "code:%s\n", code_str);
+ struct kvm_regs regs;
+ struct kvm_sregs sregs;
+ int r, n;
+ int back_offset;
+ unsigned char code;
+ char code_str[SHOW_CODE_LEN * 3 + 1];
+ unsigned long rip;
+
+ r = kvm_vcpu_ioctl(env, KVM_GET_SREGS, &sregs);
+ if (r < 0 ) {
+ perror("KVM_GET_SREGS");
+ return;
+ }
+ r = kvm_vcpu_ioctl(env, KVM_GET_REGS, ®s);
+ if (r < 0) {
+ perror("KVM_GET_REGS");
+ return;
+ }
+ rip = sregs.cs.base + regs.rip;
+ back_offset = regs.rip;
+ if (back_offset > 20)
+ back_offset = 20;
+ *code_str = 0;
+ for (n = -back_offset; n < SHOW_CODE_LEN-back_offset; ++n) {
+ if (n == 0)
+ strcat(code_str, " -->");
+ cpu_physical_memory_rw(rip + n, &code, 1, 1);
+ sprintf(code_str + strlen(code_str), " %02x", code);
+ }
+ fprintf(stderr, "code:%s\n", code_str);
}
@@ -323,26 +321,26 @@ void kvm_show_code(CPUState *env)
*/
static struct kvm_msr_list *kvm_get_msr_list(void)
{
- struct kvm_msr_list sizer, *msrs;
- int r;
-
- sizer.nmsrs = 0;
- r = kvm_ioctl(kvm_state, KVM_GET_MSR_INDEX_LIST, &sizer);
- if (r < 0 && r != -E2BIG)
- return NULL;
- /* Old kernel modules had a bug and could write beyond the provided
- memory. Allocate at least a safe amount of 1K. */
- msrs = qemu_malloc(MAX(1024, sizeof(*msrs) +
- sizer.nmsrs * sizeof(*msrs->indices)));
-
- msrs->nmsrs = sizer.nmsrs;
- r = kvm_ioctl(kvm_state, KVM_GET_MSR_INDEX_LIST, msrs);
- if (r < 0) {
- free(msrs);
- errno = r;
- return NULL;
- }
- return msrs;
+ struct kvm_msr_list sizer, *msrs;
+ int r;
+
+ sizer.nmsrs = 0;
+ r = kvm_ioctl(kvm_state, KVM_GET_MSR_INDEX_LIST, &sizer);
+ if (r < 0 && r != -E2BIG)
+ return NULL;
+ /* Old kernel modules had a bug and could write beyond the provided
+ memory. Allocate at least a safe amount of 1K. */
+ msrs = qemu_malloc(MAX(1024, sizeof(*msrs) +
+ sizer.nmsrs * sizeof(*msrs->indices)));
+
+ msrs->nmsrs = sizer.nmsrs;
+ r = kvm_ioctl(kvm_state, KVM_GET_MSR_INDEX_LIST, msrs);
+ if (r < 0) {
+ free(msrs);
+ errno = r;
+ return NULL;
+ }
+ return msrs;
}
int kvm_get_msrs(CPUState *env, struct kvm_msr_entry *msrs, int n)
@@ -405,130 +403,130 @@ int kvm_set_mce(CPUState *env, struct kvm_x86_mce *m)
static void print_seg(FILE *file, const char *name, struct kvm_segment *seg)
{
- fprintf(stderr,
- "%s %04x (%08llx/%08x p %d dpl %d db %d s %d type %x l %d"
- " g %d avl %d)\n",
- name, seg->selector, seg->base, seg->limit, seg->present,
- seg->dpl, seg->db, seg->s, seg->type, seg->l, seg->g,
- seg->avl);
+ fprintf(stderr,
+ "%s %04x (%08llx/%08x p %d dpl %d db %d s %d type %x l %d"
+ " g %d avl %d)\n",
+ name, seg->selector, seg->base, seg->limit, seg->present,
+ seg->dpl, seg->db, seg->s, seg->type, seg->l, seg->g,
+ seg->avl);
}
static void print_dt(FILE *file, const char *name, struct kvm_dtable *dt)
{
- fprintf(stderr, "%s %llx/%x\n", name, dt->base, dt->limit);
+ fprintf(stderr, "%s %llx/%x\n", name, dt->base, dt->limit);
}
void kvm_show_regs(CPUState *env)
{
- struct kvm_regs regs;
- struct kvm_sregs sregs;
- int r;
-
- r = kvm_vcpu_ioctl(env, KVM_GET_REGS, ®s);
- if (r < 0) {
- perror("KVM_GET_REGS");
- return;
- }
- fprintf(stderr,
- "rax %016llx rbx %016llx rcx %016llx rdx %016llx\n"
- "rsi %016llx rdi %016llx rsp %016llx rbp %016llx\n"
- "r8 %016llx r9 %016llx r10 %016llx r11 %016llx\n"
- "r12 %016llx r13 %016llx r14 %016llx r15 %016llx\n"
- "rip %016llx rflags %08llx\n",
- regs.rax, regs.rbx, regs.rcx, regs.rdx,
- regs.rsi, regs.rdi, regs.rsp, regs.rbp,
- regs.r8, regs.r9, regs.r10, regs.r11,
- regs.r12, regs.r13, regs.r14, regs.r15,
- regs.rip, regs.rflags);
- r = kvm_vcpu_ioctl(env, KVM_GET_SREGS, &sregs);
- if (r < 0) {
- perror("KVM_GET_SREGS");
- return;
- }
- print_seg(stderr, "cs", &sregs.cs);
- print_seg(stderr, "ds", &sregs.ds);
- print_seg(stderr, "es", &sregs.es);
- print_seg(stderr, "ss", &sregs.ss);
- print_seg(stderr, "fs", &sregs.fs);
- print_seg(stderr, "gs", &sregs.gs);
- print_seg(stderr, "tr", &sregs.tr);
- print_seg(stderr, "ldt", &sregs.ldt);
- print_dt(stderr, "gdt", &sregs.gdt);
- print_dt(stderr, "idt", &sregs.idt);
- fprintf(stderr, "cr0 %llx cr2 %llx cr3 %llx cr4 %llx cr8 %llx"
- " efer %llx\n",
- sregs.cr0, sregs.cr2, sregs.cr3, sregs.cr4, sregs.cr8,
- sregs.efer);
+ struct kvm_regs regs;
+ struct kvm_sregs sregs;
+ int r;
+
+ r = kvm_vcpu_ioctl(env, KVM_GET_REGS, ®s);
+ if (r < 0) {
+ perror("KVM_GET_REGS");
+ return;
+ }
+ fprintf(stderr,
+ "rax %016llx rbx %016llx rcx %016llx rdx %016llx\n"
+ "rsi %016llx rdi %016llx rsp %016llx rbp %016llx\n"
+ "r8 %016llx r9 %016llx r10 %016llx r11 %016llx\n"
+ "r12 %016llx r13 %016llx r14 %016llx r15 %016llx\n"
+ "rip %016llx rflags %08llx\n",
+ regs.rax, regs.rbx, regs.rcx, regs.rdx,
+ regs.rsi, regs.rdi, regs.rsp, regs.rbp,
+ regs.r8, regs.r9, regs.r10, regs.r11,
+ regs.r12, regs.r13, regs.r14, regs.r15,
+ regs.rip, regs.rflags);
+ r = kvm_vcpu_ioctl(env, KVM_GET_SREGS, &sregs);
+ if (r < 0) {
+ perror("KVM_GET_SREGS");
+ return;
+ }
+ print_seg(stderr, "cs", &sregs.cs);
+ print_seg(stderr, "ds", &sregs.ds);
+ print_seg(stderr, "es", &sregs.es);
+ print_seg(stderr, "ss", &sregs.ss);
+ print_seg(stderr, "fs", &sregs.fs);
+ print_seg(stderr, "gs", &sregs.gs);
+ print_seg(stderr, "tr", &sregs.tr);
+ print_seg(stderr, "ldt", &sregs.ldt);
+ print_dt(stderr, "gdt", &sregs.gdt);
+ print_dt(stderr, "idt", &sregs.idt);
+ fprintf(stderr, "cr0 %llx cr2 %llx cr3 %llx cr4 %llx cr8 %llx"
+ " efer %llx\n",
+ sregs.cr0, sregs.cr2, sregs.cr3, sregs.cr4, sregs.cr8,
+ sregs.efer);
}
static void kvm_set_cr8(CPUState *env, uint64_t cr8)
{
- env->kvm_run->cr8 = cr8;
+ env->kvm_run->cr8 = cr8;
}
int kvm_setup_cpuid(CPUState *env, int nent,
- struct kvm_cpuid_entry *entries)
+ struct kvm_cpuid_entry *entries)
{
- struct kvm_cpuid *cpuid;
- int r;
+ struct kvm_cpuid *cpuid;
+ int r;
- cpuid = qemu_malloc(sizeof(*cpuid) + nent * sizeof(*entries));
+ cpuid = qemu_malloc(sizeof(*cpuid) + nent * sizeof(*entries));
- cpuid->nent = nent;
- memcpy(cpuid->entries, entries, nent * sizeof(*entries));
- r = kvm_vcpu_ioctl(env, KVM_SET_CPUID, cpuid);
+ cpuid->nent = nent;
+ memcpy(cpuid->entries, entries, nent * sizeof(*entries));
+ r = kvm_vcpu_ioctl(env, KVM_SET_CPUID, cpuid);
- free(cpuid);
- return r;
+ free(cpuid);
+ return r;
}
int kvm_setup_cpuid2(CPUState *env, int nent,
- struct kvm_cpuid_entry2 *entries)
+ struct kvm_cpuid_entry2 *entries)
{
- struct kvm_cpuid2 *cpuid;
- int r;
+ struct kvm_cpuid2 *cpuid;
+ int r;
- cpuid = qemu_malloc(sizeof(*cpuid) + nent * sizeof(*entries));
+ cpuid = qemu_malloc(sizeof(*cpuid) + nent * sizeof(*entries));
- cpuid->nent = nent;
- memcpy(cpuid->entries, entries, nent * sizeof(*entries));
- r = kvm_vcpu_ioctl(env, KVM_SET_CPUID2, cpuid);
- free(cpuid);
- return r;
+ cpuid->nent = nent;
+ memcpy(cpuid->entries, entries, nent * sizeof(*entries));
+ r = kvm_vcpu_ioctl(env, KVM_SET_CPUID2, cpuid);
+ free(cpuid);
+ return r;
}
int kvm_set_shadow_pages(kvm_context_t kvm, unsigned int nrshadow_pages)
{
#ifdef KVM_CAP_MMU_SHADOW_CACHE_CONTROL
- int r;
-
- r = kvm_ioctl(kvm_state, KVM_CHECK_EXTENSION,
- KVM_CAP_MMU_SHADOW_CACHE_CONTROL);
- if (r > 0) {
- r = kvm_vm_ioctl(kvm_state, KVM_SET_NR_MMU_PAGES, nrshadow_pages);
- if (r < 0) {
- fprintf(stderr, "kvm_set_shadow_pages: %m\n");
- return r;
- }
- return 0;
- }
+ int r;
+
+ r = kvm_ioctl(kvm_state, KVM_CHECK_EXTENSION,
+ KVM_CAP_MMU_SHADOW_CACHE_CONTROL);
+ if (r > 0) {
+ r = kvm_vm_ioctl(kvm_state, KVM_SET_NR_MMU_PAGES, nrshadow_pages);
+ if (r < 0) {
+ fprintf(stderr, "kvm_set_shadow_pages: %m\n");
+ return r;
+ }
+ return 0;
+ }
#endif
- return -1;
+ return -1;
}
int kvm_get_shadow_pages(kvm_context_t kvm, unsigned int *nrshadow_pages)
{
#ifdef KVM_CAP_MMU_SHADOW_CACHE_CONTROL
- int r;
-
- r = kvm_ioctl(kvm_state, KVM_CHECK_EXTENSION,
- KVM_CAP_MMU_SHADOW_CACHE_CONTROL);
- if (r > 0) {
- *nrshadow_pages = kvm_vm_ioctl(kvm_state, KVM_GET_NR_MMU_PAGES);
- return 0;
- }
+ int r;
+
+ r = kvm_ioctl(kvm_state, KVM_CHECK_EXTENSION,
+ KVM_CAP_MMU_SHADOW_CACHE_CONTROL);
+ if (r > 0) {
+ *nrshadow_pages = kvm_vm_ioctl(kvm_state, KVM_GET_NR_MMU_PAGES);
+ return 0;
+ }
#endif
- return -1;
+ return -1;
}
#ifdef KVM_CAP_VAPIC
@@ -588,10 +586,10 @@ int kvm_arch_qemu_create_context(void)
kvm_msr_list = kvm_get_msr_list();
if (!kvm_msr_list)
- return -1;
+ return -1;
for (i = 0; i < kvm_msr_list->nmsrs; ++i) {
- if (kvm_msr_list->indices[i] == MSR_STAR)
- kvm_has_msr_star = 1;
+ if (kvm_msr_list->indices[i] == MSR_STAR)
+ kvm_has_msr_star = 1;
if (kvm_msr_list->indices[i] == MSR_VM_HSAVE_PA)
kvm_has_vm_hsave_pa = 1;
}
@@ -612,65 +610,65 @@ int kvm_arch_qemu_create_context(void)
/* returns 0 on success, non-0 on failure */
static int get_msr_entry(struct kvm_msr_entry *entry, CPUState *env)
{
- switch (entry->index) {
- case MSR_IA32_SYSENTER_CS:
- env->sysenter_cs = entry->data;
- break;
- case MSR_IA32_SYSENTER_ESP:
- env->sysenter_esp = entry->data;
- break;
- case MSR_IA32_SYSENTER_EIP:
- env->sysenter_eip = entry->data;
- break;
- case MSR_STAR:
- env->star = entry->data;
- break;
+ switch (entry->index) {
+ case MSR_IA32_SYSENTER_CS:
+ env->sysenter_cs = entry->data;
+ break;
+ case MSR_IA32_SYSENTER_ESP:
+ env->sysenter_esp = entry->data;
+ break;
+ case MSR_IA32_SYSENTER_EIP:
+ env->sysenter_eip = entry->data;
+ break;
+ case MSR_STAR:
+ env->star = entry->data;
+ break;
#ifdef TARGET_X86_64
- case MSR_CSTAR:
- env->cstar = entry->data;
- break;
- case MSR_KERNELGSBASE:
- env->kernelgsbase = entry->data;
- break;
- case MSR_FMASK:
- env->fmask = entry->data;
- break;
- case MSR_LSTAR:
- env->lstar = entry->data;
- break;
+ case MSR_CSTAR:
+ env->cstar = entry->data;
+ break;
+ case MSR_KERNELGSBASE:
+ env->kernelgsbase = entry->data;
+ break;
+ case MSR_FMASK:
+ env->fmask = entry->data;
+ break;
+ case MSR_LSTAR:
+ env->lstar = entry->data;
+ break;
#endif
- case MSR_IA32_TSC:
- env->tsc = entry->data;
- break;
- case MSR_VM_HSAVE_PA:
- env->vm_hsave = entry->data;
- break;
- case MSR_KVM_SYSTEM_TIME:
- env->system_time_msr = entry->data;
- break;
- case MSR_KVM_WALL_CLOCK:
- env->wall_clock_msr = entry->data;
- break;
+ case MSR_IA32_TSC:
+ env->tsc = entry->data;
+ break;
+ case MSR_VM_HSAVE_PA:
+ env->vm_hsave = entry->data;
+ break;
+ case MSR_KVM_SYSTEM_TIME:
+ env->system_time_msr = entry->data;
+ break;
+ case MSR_KVM_WALL_CLOCK:
+ env->wall_clock_msr = entry->data;
+ break;
#ifdef KVM_CAP_MCE
- case MSR_MCG_STATUS:
- env->mcg_status = entry->data;
- break;
- case MSR_MCG_CTL:
- env->mcg_ctl = entry->data;
- break;
+ case MSR_MCG_STATUS:
+ env->mcg_status = entry->data;
+ break;
+ case MSR_MCG_CTL:
+ env->mcg_ctl = entry->data;
+ break;
#endif
- default:
+ default:
#ifdef KVM_CAP_MCE
- if (entry->index >= MSR_MC0_CTL && \
- entry->index < MSR_MC0_CTL + (env->mcg_cap & 0xff) * 4) {
- env->mce_banks[entry->index - MSR_MC0_CTL] = entry->data;
- break;
- }
-#endif
- printf("Warning unknown msr index 0x%x\n", entry->index);
- return 1;
+ if (entry->index >= MSR_MC0_CTL && \
+ entry->index < MSR_MC0_CTL + (env->mcg_cap & 0xff) * 4) {
+ env->mce_banks[entry->index - MSR_MC0_CTL] = entry->data;
+ break;
}
- return 0;
+#endif
+ printf("Warning unknown msr index 0x%x\n", entry->index);
+ return 1;
+ }
+ return 0;
}
static void kvm_arch_save_mpstate(CPUState *env)
@@ -762,14 +760,14 @@ static void get_seg(SegmentCache *lhs, const struct kvm_segment *rhs)
lhs->base = rhs->base;
lhs->limit = rhs->limit;
lhs->flags =
- (rhs->type << DESC_TYPE_SHIFT)
- | (rhs->present * DESC_P_MASK)
- | (rhs->dpl << DESC_DPL_SHIFT)
- | (rhs->db << DESC_B_SHIFT)
- | (rhs->s * DESC_S_MASK)
- | (rhs->l << DESC_L_SHIFT)
- | (rhs->g * DESC_G_MASK)
- | (rhs->avl * DESC_AVL_MASK);
+ (rhs->type << DESC_TYPE_SHIFT)
+ | (rhs->present * DESC_P_MASK)
+ | (rhs->dpl << DESC_DPL_SHIFT)
+ | (rhs->db << DESC_B_SHIFT)
+ | (rhs->s * DESC_S_MASK)
+ | (rhs->l << DESC_L_SHIFT)
+ | (rhs->g * DESC_G_MASK)
+ | (rhs->avl * DESC_AVL_MASK);
}
#define XSAVE_CWD_RIP 2
@@ -831,13 +829,13 @@ void kvm_arch_load_regs(CPUState *env, int level)
xsave->region[0] = (uint32_t)(swd << 16) + cwd;
xsave->region[1] = (uint32_t)(fop << 16) + twd;
memcpy(&xsave->region[XSAVE_ST_SPACE], env->fpregs,
- sizeof env->fpregs);
+ sizeof env->fpregs);
memcpy(&xsave->region[XSAVE_XMM_SPACE], env->xmm_regs,
- sizeof env->xmm_regs);
+ sizeof env->xmm_regs);
xsave->region[XSAVE_MXCSR] = env->mxcsr;
*(uint64_t *)&xsave->region[XSAVE_XSTATE_BV] = env->xstate_bv;
memcpy(&xsave->region[XSAVE_YMMH_SPACE], env->ymmh_regs,
- sizeof env->ymmh_regs);
+ sizeof env->ymmh_regs);
kvm_set_xsave(env, xsave);
if (kvm_check_extension(kvm_state, KVM_CAP_XCRS)) {
struct kvm_xcrs xcrs;
@@ -872,26 +870,26 @@ void kvm_arch_load_regs(CPUState *env, int level)
}
if ((env->eflags & VM_MASK)) {
- set_v8086_seg(&sregs.cs, &env->segs[R_CS]);
- set_v8086_seg(&sregs.ds, &env->segs[R_DS]);
- set_v8086_seg(&sregs.es, &env->segs[R_ES]);
- set_v8086_seg(&sregs.fs, &env->segs[R_FS]);
- set_v8086_seg(&sregs.gs, &env->segs[R_GS]);
- set_v8086_seg(&sregs.ss, &env->segs[R_SS]);
+ set_v8086_seg(&sregs.cs, &env->segs[R_CS]);
+ set_v8086_seg(&sregs.ds, &env->segs[R_DS]);
+ set_v8086_seg(&sregs.es, &env->segs[R_ES]);
+ set_v8086_seg(&sregs.fs, &env->segs[R_FS]);
+ set_v8086_seg(&sregs.gs, &env->segs[R_GS]);
+ set_v8086_seg(&sregs.ss, &env->segs[R_SS]);
} else {
- set_seg(&sregs.cs, &env->segs[R_CS]);
- set_seg(&sregs.ds, &env->segs[R_DS]);
- set_seg(&sregs.es, &env->segs[R_ES]);
- set_seg(&sregs.fs, &env->segs[R_FS]);
- set_seg(&sregs.gs, &env->segs[R_GS]);
- set_seg(&sregs.ss, &env->segs[R_SS]);
-
- if (env->cr[0] & CR0_PE_MASK) {
- /* force ss cpl to cs cpl */
- sregs.ss.selector = (sregs.ss.selector & ~3) |
- (sregs.cs.selector & 3);
- sregs.ss.dpl = sregs.ss.selector & 3;
- }
+ set_seg(&sregs.cs, &env->segs[R_CS]);
+ set_seg(&sregs.ds, &env->segs[R_DS]);
+ set_seg(&sregs.es, &env->segs[R_ES]);
+ set_seg(&sregs.fs, &env->segs[R_FS]);
+ set_seg(&sregs.gs, &env->segs[R_GS]);
+ set_seg(&sregs.ss, &env->segs[R_SS]);
+
+ if (env->cr[0] & CR0_PE_MASK) {
+ /* force ss cpl to cs cpl */
+ sregs.ss.selector = (sregs.ss.selector & ~3) |
+ (sregs.cs.selector & 3);
+ sregs.ss.dpl = sregs.ss.selector & 3;
+ }
}
set_seg(&sregs.tr, &env->tr);
@@ -921,7 +919,7 @@ void kvm_arch_load_regs(CPUState *env, int level)
kvm_msr_entry_set(&msrs[n++], MSR_IA32_SYSENTER_ESP, env->sysenter_esp);
kvm_msr_entry_set(&msrs[n++], MSR_IA32_SYSENTER_EIP, env->sysenter_eip);
if (kvm_has_msr_star)
- kvm_msr_entry_set(&msrs[n++], MSR_STAR, env->star);
+ kvm_msr_entry_set(&msrs[n++], MSR_STAR, env->star);
if (kvm_has_vm_hsave_pa)
kvm_msr_entry_set(&msrs[n++], MSR_VM_HSAVE_PA, env->vm_hsave);
#ifdef TARGET_X86_64
@@ -1097,21 +1095,19 @@ void kvm_arch_save_regs(CPUState *env)
env->efer = sregs.efer;
//cpu_set_apic_tpr(env, sregs.cr8);
-#define HFLAG_COPY_MASK ~( \
- HF_CPL_MASK | HF_PE_MASK | HF_MP_MASK | HF_EM_MASK | \
- HF_TS_MASK | HF_TF_MASK | HF_VM_MASK | HF_IOPL_MASK | \
- HF_OSFXSR_MASK | HF_LMA_MASK | HF_CS32_MASK | \
- HF_SS32_MASK | HF_CS64_MASK | HF_ADDSEG_MASK)
-
-
+#define HFLAG_COPY_MASK ~( \
+ HF_CPL_MASK | HF_PE_MASK | HF_MP_MASK | HF_EM_MASK | \
+ HF_TS_MASK | HF_TF_MASK | HF_VM_MASK | HF_IOPL_MASK | \
+ HF_OSFXSR_MASK | HF_LMA_MASK | HF_CS32_MASK | \
+ HF_SS32_MASK | HF_CS64_MASK | HF_ADDSEG_MASK)
hflags = (env->segs[R_CS].flags >> DESC_DPL_SHIFT) & HF_CPL_MASK;
hflags |= (env->cr[0] & CR0_PE_MASK) << (HF_PE_SHIFT - CR0_PE_SHIFT);
hflags |= (env->cr[0] << (HF_MP_SHIFT - CR0_MP_SHIFT)) &
- (HF_MP_MASK | HF_EM_MASK | HF_TS_MASK);
+ (HF_MP_MASK | HF_EM_MASK | HF_TS_MASK);
hflags |= (env->eflags & (HF_TF_MASK | HF_VM_MASK | HF_IOPL_MASK));
hflags |= (env->cr[4] & CR4_OSFXSR_MASK) <<
- (HF_OSFXSR_SHIFT - CR4_OSFXSR_SHIFT);
+ (HF_OSFXSR_SHIFT - CR4_OSFXSR_SHIFT);
if (env->efer & MSR_EFER_LMA) {
hflags |= HF_LMA_MASK;
@@ -1121,19 +1117,19 @@ void kvm_arch_save_regs(CPUState *env)
hflags |= HF_CS32_MASK | HF_SS32_MASK | HF_CS64_MASK;
} else {
hflags |= (env->segs[R_CS].flags & DESC_B_MASK) >>
- (DESC_B_SHIFT - HF_CS32_SHIFT);
+ (DESC_B_SHIFT - HF_CS32_SHIFT);
hflags |= (env->segs[R_SS].flags & DESC_B_MASK) >>
- (DESC_B_SHIFT - HF_SS32_SHIFT);
+ (DESC_B_SHIFT - HF_SS32_SHIFT);
if (!(env->cr[0] & CR0_PE_MASK) ||
- (env->eflags & VM_MASK) ||
- !(hflags & HF_CS32_MASK)) {
- hflags |= HF_ADDSEG_MASK;
- } else {
- hflags |= ((env->segs[R_DS].base |
- env->segs[R_ES].base |
- env->segs[R_SS].base) != 0) <<
- HF_ADDSEG_SHIFT;
- }
+ (env->eflags & VM_MASK) ||
+ !(hflags & HF_CS32_MASK)) {
+ hflags |= HF_ADDSEG_MASK;
+ } else {
+ hflags |= ((env->segs[R_DS].base |
+ env->segs[R_ES].base |
+ env->segs[R_SS].base) != 0) <<
+ HF_ADDSEG_SHIFT;
+ }
}
env->hflags = (env->hflags & HFLAG_COPY_MASK) | hflags;
@@ -1144,7 +1140,7 @@ void kvm_arch_save_regs(CPUState *env)
msrs[n++].index = MSR_IA32_SYSENTER_ESP;
msrs[n++].index = MSR_IA32_SYSENTER_EIP;
if (kvm_has_msr_star)
- msrs[n++].index = MSR_STAR;
+ msrs[n++].index = MSR_STAR;
msrs[n++].index = MSR_IA32_TSC;
if (kvm_has_vm_hsave_pa)
msrs[n++].index = MSR_VM_HSAVE_PA;
@@ -1222,9 +1218,9 @@ int kvm_arch_halt(CPUState *env)
{
if (!((env->interrupt_request & CPU_INTERRUPT_HARD) &&
- (env->eflags & IF_MASK)) &&
- !(env->interrupt_request & CPU_INTERRUPT_NMI)) {
- env->halted = 1;
+ (env->eflags & IF_MASK)) &&
+ !(env->interrupt_request & CPU_INTERRUPT_NMI)) {
+ env->halted = 1;
}
return 1;
}
@@ -1232,16 +1228,16 @@ int kvm_arch_halt(CPUState *env)
int kvm_arch_pre_run(CPUState *env, struct kvm_run *run)
{
if (!kvm_irqchip_in_kernel())
- kvm_set_cr8(env, cpu_get_apic_tpr(env->apic_state));
+ kvm_set_cr8(env, cpu_get_apic_tpr(env->apic_state));
return 0;
}
int kvm_arch_has_work(CPUState *env)
{
if (((env->interrupt_request & CPU_INTERRUPT_HARD) &&
- (env->eflags & IF_MASK)) ||
- (env->interrupt_request & CPU_INTERRUPT_NMI))
- return 1;
+ (env->eflags & IF_MASK)) ||
+ (env->interrupt_request & CPU_INTERRUPT_NMI))
+ return 1;
return 0;
}
@@ -1253,13 +1249,13 @@ int kvm_arch_try_push_interrupts(void *opaque)
if (kvm_is_ready_for_interrupt_injection(env) &&
(env->interrupt_request & CPU_INTERRUPT_HARD) &&
(env->eflags & IF_MASK)) {
- env->interrupt_request &= ~CPU_INTERRUPT_HARD;
- irq = cpu_get_pic_interrupt(env);
- if (irq >= 0) {
- r = kvm_inject_irq(env, irq);
- if (r < 0)
- printf("cpu %d fail inject %x\n", env->cpu_index, irq);
- }
+ env->interrupt_request &= ~CPU_INTERRUPT_HARD;
+ irq = cpu_get_pic_interrupt(env);
+ if (irq >= 0) {
+ r = kvm_inject_irq(env, irq);
+ if (r < 0)
+ printf("cpu %d fail inject %x\n", env->cpu_index, irq);
+ }
}
return (env->interrupt_request & CPU_INTERRUPT_HARD) != 0;
--
1.7.1
^ permalink raw reply related [flat|nested] 7+ messages in thread* [PATCH 3/4] qemu-kvm-x86.c: add braces where appropriate
2010-09-05 12:13 [PATCH 0/4] Apply some CODING_STYLE to qemu-kvm*.c Avi Kivity
2010-09-05 12:13 ` [PATCH 1/4] qemu-kvm-x86.c: reindent Avi Kivity
2010-09-05 12:13 ` [PATCH 2/4] qemu-kvm-x86.c: remove extraneous line continuation Avi Kivity
@ 2010-09-05 12:13 ` Avi Kivity
2010-09-05 12:13 ` [PATCH 4/4] qemu-kvm.c: " Avi Kivity
` (2 subsequent siblings)
5 siblings, 0 replies; 7+ messages in thread
From: Avi Kivity @ 2010-09-05 12:13 UTC (permalink / raw)
To: Marcelo Tosatti, kvm
Adjust to comply with CODING_STYLE, at least where braces are concerned.
Signed-off-by: Avi Kivity <avi@redhat.com>
---
qemu-kvm-x86.c | 149 ++++++++++++++++++++++++++++++++++++--------------------
1 files changed, 96 insertions(+), 53 deletions(-)
diff --git a/qemu-kvm-x86.c b/qemu-kvm-x86.c
index c5d44e0..46257d6 100644
--- a/qemu-kvm-x86.c
+++ b/qemu-kvm-x86.c
@@ -123,9 +123,9 @@ static int kvm_create_pit(kvm_context_t kvm)
r = kvm_ioctl(kvm_state, KVM_CHECK_EXTENSION, KVM_CAP_PIT);
if (r > 0) {
r = kvm_vm_ioctl(kvm_state, KVM_CREATE_PIT);
- if (r >= 0)
+ if (r >= 0) {
kvm_state->pit_in_kernel = 1;
- else {
+ } else {
fprintf(stderr, "Create kernel PIC irqchip failed\n");
return r;
}
@@ -141,20 +141,24 @@ int kvm_arch_create(kvm_context_t kvm, unsigned long phys_mem_bytes,
int r = 0;
r = kvm_init_tss(kvm);
- if (r < 0)
+ if (r < 0) {
return r;
+ }
r = kvm_init_identity_map_page(kvm);
- if (r < 0)
+ if (r < 0) {
return r;
+ }
r = kvm_create_pit(kvm);
- if (r < 0)
+ if (r < 0) {
return r;
+ }
r = kvm_init_coalesced_mmio(kvm);
- if (r < 0)
+ if (r < 0) {
return r;
+ }
return 0;
}
@@ -211,12 +215,14 @@ int kvm_get_lapic(CPUState *env, struct kvm_lapic_state *s)
{
int r = 0;
- if (!kvm_irqchip_in_kernel())
+ if (!kvm_irqchip_in_kernel()) {
return r;
+ }
r = kvm_vcpu_ioctl(env, KVM_GET_LAPIC, s);
- if (r < 0)
+ if (r < 0) {
fprintf(stderr, "KVM_GET_LAPIC failed\n");
+ }
return r;
}
@@ -224,13 +230,15 @@ int kvm_set_lapic(CPUState *env, struct kvm_lapic_state *s)
{
int r = 0;
- if (!kvm_irqchip_in_kernel())
+ if (!kvm_irqchip_in_kernel()) {
return 0;
+ }
r = kvm_vcpu_ioctl(env, KVM_SET_LAPIC, s);
- if (r < 0)
+ if (r < 0) {
fprintf(stderr, "KVM_SET_LAPIC failed\n");
+ }
return r;
}
@@ -240,30 +248,34 @@ int kvm_set_lapic(CPUState *env, struct kvm_lapic_state *s)
int kvm_get_pit(kvm_context_t kvm, struct kvm_pit_state *s)
{
- if (!kvm_pit_in_kernel())
+ if (!kvm_pit_in_kernel()) {
return 0;
+ }
return kvm_vm_ioctl(kvm_state, KVM_GET_PIT, s);
}
int kvm_set_pit(kvm_context_t kvm, struct kvm_pit_state *s)
{
- if (!kvm_pit_in_kernel())
+ if (!kvm_pit_in_kernel()) {
return 0;
+ }
return kvm_vm_ioctl(kvm_state, KVM_SET_PIT, s);
}
#ifdef KVM_CAP_PIT_STATE2
int kvm_get_pit2(kvm_context_t kvm, struct kvm_pit_state2 *ps2)
{
- if (!kvm_pit_in_kernel())
+ if (!kvm_pit_in_kernel()) {
return 0;
+ }
return kvm_vm_ioctl(kvm_state, KVM_GET_PIT2, ps2);
}
int kvm_set_pit2(kvm_context_t kvm, struct kvm_pit_state2 *ps2)
{
- if (!kvm_pit_in_kernel())
+ if (!kvm_pit_in_kernel()) {
return 0;
+ }
return kvm_vm_ioctl(kvm_state, KVM_SET_PIT2, ps2);
}
@@ -303,12 +315,14 @@ void kvm_show_code(CPUState *env)
}
rip = sregs.cs.base + regs.rip;
back_offset = regs.rip;
- if (back_offset > 20)
+ if (back_offset > 20) {
back_offset = 20;
+ }
*code_str = 0;
for (n = -back_offset; n < SHOW_CODE_LEN-back_offset; ++n) {
- if (n == 0)
+ if (n == 0) {
strcat(code_str, " -->");
+ }
cpu_physical_memory_rw(rip + n, &code, 1, 1);
sprintf(code_str + strlen(code_str), " %02x", code);
}
@@ -326,8 +340,9 @@ static struct kvm_msr_list *kvm_get_msr_list(void)
sizer.nmsrs = 0;
r = kvm_ioctl(kvm_state, KVM_GET_MSR_INDEX_LIST, &sizer);
- if (r < 0 && r != -E2BIG)
+ if (r < 0 && r != -E2BIG) {
return NULL;
+ }
/* Old kernel modules had a bug and could write beyond the provided
memory. Allocate at least a safe amount of 1K. */
msrs = qemu_malloc(MAX(1024, sizeof(*msrs) +
@@ -536,8 +551,9 @@ static int kvm_enable_tpr_access_reporting(CPUState *env)
struct kvm_tpr_access_ctl tac = { .enabled = 1 };
r = kvm_ioctl(env->kvm_state, KVM_CHECK_EXTENSION, KVM_CAP_VAPIC);
- if (r <= 0)
+ if (r <= 0) {
return -ENOSYS;
+ }
return kvm_vcpu_ioctl(env, KVM_TPR_ACCESS_REPORTING, &tac);
}
#endif
@@ -581,22 +597,27 @@ int kvm_arch_qemu_create_context(void)
uname(&utsname);
lm_capable_kernel = strcmp(utsname.machine, "x86_64") == 0;
- if (kvm_shadow_memory)
+ if (kvm_shadow_memory) {
kvm_set_shadow_pages(kvm_context, kvm_shadow_memory);
+ }
kvm_msr_list = kvm_get_msr_list();
- if (!kvm_msr_list)
+ if (!kvm_msr_list) {
return -1;
+ }
for (i = 0; i < kvm_msr_list->nmsrs; ++i) {
- if (kvm_msr_list->indices[i] == MSR_STAR)
+ if (kvm_msr_list->indices[i] == MSR_STAR) {
kvm_has_msr_star = 1;
- if (kvm_msr_list->indices[i] == MSR_VM_HSAVE_PA)
+ }
+ if (kvm_msr_list->indices[i] == MSR_VM_HSAVE_PA) {
kvm_has_vm_hsave_pa = 1;
+ }
}
#ifdef KVM_CAP_ADJUST_CLOCK
- if (kvm_check_extension(kvm_state, KVM_CAP_ADJUST_CLOCK))
+ if (kvm_check_extension(kvm_state, KVM_CAP_ADJUST_CLOCK)) {
vmstate_register(NULL, 0, &vmstate_kvmclock, &kvmclock_data);
+ }
#endif
r = kvm_set_boot_cpu_id(0);
@@ -824,8 +845,9 @@ void kvm_arch_load_regs(CPUState *env, int level)
swd = env->fpus & ~(7 << 11);
swd |= (env->fpstt & 7) << 11;
cwd = env->fpuc;
- for (i = 0; i < 8; ++i)
+ for (i = 0; i < 8; ++i) {
twd |= (!env->fptags[i]) << i;
+ }
xsave->region[0] = (uint32_t)(swd << 16) + cwd;
xsave->region[1] = (uint32_t)(fop << 16) + twd;
memcpy(&xsave->region[XSAVE_ST_SPACE], env->fpregs,
@@ -853,8 +875,9 @@ void kvm_arch_load_regs(CPUState *env, int level)
fpu.fsw = env->fpus & ~(7 << 11);
fpu.fsw |= (env->fpstt & 7) << 11;
fpu.fcw = env->fpuc;
- for (i = 0; i < 8; ++i)
+ for (i = 0; i < 8; ++i) {
fpu.ftwx |= (!env->fptags[i]) << i;
+ }
memcpy(fpu.fpr, env->fpregs, sizeof env->fpregs);
memcpy(fpu.xmm, env->xmm_regs, sizeof env->xmm_regs);
fpu.mxcsr = env->mxcsr;
@@ -918,10 +941,12 @@ void kvm_arch_load_regs(CPUState *env, int level)
kvm_msr_entry_set(&msrs[n++], MSR_IA32_SYSENTER_CS, env->sysenter_cs);
kvm_msr_entry_set(&msrs[n++], MSR_IA32_SYSENTER_ESP, env->sysenter_esp);
kvm_msr_entry_set(&msrs[n++], MSR_IA32_SYSENTER_EIP, env->sysenter_eip);
- if (kvm_has_msr_star)
+ if (kvm_has_msr_star) {
kvm_msr_entry_set(&msrs[n++], MSR_STAR, env->star);
- if (kvm_has_vm_hsave_pa)
+ }
+ if (kvm_has_vm_hsave_pa) {
kvm_msr_entry_set(&msrs[n++], MSR_VM_HSAVE_PA, env->vm_hsave);
+ }
#ifdef TARGET_X86_64
if (lm_capable_kernel) {
kvm_msr_entry_set(&msrs[n++], MSR_CSTAR, env->cstar);
@@ -945,28 +970,31 @@ void kvm_arch_load_regs(CPUState *env, int level)
}
#ifdef KVM_CAP_MCE
if (env->mcg_cap) {
- if (level == KVM_PUT_RESET_STATE)
+ if (level == KVM_PUT_RESET_STATE) {
kvm_msr_entry_set(&msrs[n++], MSR_MCG_STATUS, env->mcg_status);
- else if (level == KVM_PUT_FULL_STATE) {
+ } else if (level == KVM_PUT_FULL_STATE) {
kvm_msr_entry_set(&msrs[n++], MSR_MCG_STATUS, env->mcg_status);
kvm_msr_entry_set(&msrs[n++], MSR_MCG_CTL, env->mcg_ctl);
- for (i = 0; i < (env->mcg_cap & 0xff); i++)
+ for (i = 0; i < (env->mcg_cap & 0xff); i++) {
kvm_msr_entry_set(&msrs[n++], MSR_MC0_CTL + i, env->mce_banks[i]);
+ }
}
}
#endif
rc = kvm_set_msrs(env, msrs, n);
- if (rc == -1)
+ if (rc == -1) {
perror("kvm_set_msrs FAILED");
+ }
if (level >= KVM_PUT_RESET_STATE) {
kvm_arch_load_mpstate(env);
kvm_load_lapic(env);
}
if (level == KVM_PUT_FULL_STATE) {
- if (env->kvm_vcpu_update_vapic)
+ if (env->kvm_vcpu_update_vapic) {
kvm_tpr_enable_vapic(env);
+ }
}
kvm_put_vcpu_events(env, level);
@@ -1024,8 +1052,9 @@ void kvm_arch_save_regs(CPUState *env)
env->fpstt = (swd >> 11) & 7;
env->fpus = swd;
env->fpuc = cwd;
- for (i = 0; i < 8; ++i)
+ for (i = 0; i < 8; ++i) {
env->fptags[i] = !((twd >> i) & 1);
+ }
env->mxcsr = xsave->region[XSAVE_MXCSR];
memcpy(env->fpregs, &xsave->region[XSAVE_ST_SPACE],
sizeof env->fpregs);
@@ -1038,8 +1067,9 @@ void kvm_arch_save_regs(CPUState *env)
struct kvm_xcrs xcrs;
kvm_get_xcrs(env, &xcrs);
- if (xcrs.xcrs[0].xcr == 0)
+ if (xcrs.xcrs[0].xcr == 0) {
env->xcr0 = xcrs.xcrs[0].value;
+ }
}
qemu_free(xsave);
} else {
@@ -1048,8 +1078,9 @@ void kvm_arch_save_regs(CPUState *env)
env->fpstt = (fpu.fsw >> 11) & 7;
env->fpus = fpu.fsw;
env->fpuc = fpu.fcw;
- for (i = 0; i < 8; ++i)
+ for (i = 0; i < 8; ++i) {
env->fptags[i] = !((fpu.ftwx >> i) & 1);
+ }
memcpy(env->fpregs, fpu.fpr, sizeof env->fpregs);
memcpy(env->xmm_regs, fpu.xmm, sizeof env->xmm_regs);
env->mxcsr = fpu.mxcsr;
@@ -1139,8 +1170,9 @@ void kvm_arch_save_regs(CPUState *env)
msrs[n++].index = MSR_IA32_SYSENTER_CS;
msrs[n++].index = MSR_IA32_SYSENTER_ESP;
msrs[n++].index = MSR_IA32_SYSENTER_EIP;
- if (kvm_has_msr_star)
+ if (kvm_has_msr_star) {
msrs[n++].index = MSR_STAR;
+ }
msrs[n++].index = MSR_IA32_TSC;
if (kvm_has_vm_hsave_pa)
msrs[n++].index = MSR_VM_HSAVE_PA;
@@ -1167,12 +1199,12 @@ void kvm_arch_save_regs(CPUState *env)
rc = kvm_get_msrs(env, msrs, n);
if (rc == -1) {
perror("kvm_get_msrs FAILED");
- }
- else {
+ } else {
n = rc; /* actual number of MSRs */
for (i=0 ; i<n; i++) {
- if (get_msr_entry(&msrs[i], env))
+ if (get_msr_entry(&msrs[i], env)) {
return;
+ }
}
}
kvm_arch_save_mpstate(env);
@@ -1192,17 +1224,18 @@ static int _kvm_arch_init_vcpu(CPUState *env)
uint64_t mcg_cap;
int banks;
- if (kvm_get_mce_cap_supported(kvm_context, &mcg_cap, &banks))
+ if (kvm_get_mce_cap_supported(kvm_context, &mcg_cap, &banks)) {
perror("kvm_get_mce_cap_supported FAILED");
- else {
+ } else {
if (banks > MCE_BANKS_DEF)
banks = MCE_BANKS_DEF;
mcg_cap &= MCE_CAP_DEF;
mcg_cap |= banks;
- if (kvm_setup_mce(env, &mcg_cap))
+ if (kvm_setup_mce(env, &mcg_cap)) {
perror("kvm_setup_mce FAILED");
- else
+ } else {
env->mcg_cap = mcg_cap;
+ }
}
}
#endif
@@ -1227,8 +1260,9 @@ int kvm_arch_halt(CPUState *env)
int kvm_arch_pre_run(CPUState *env, struct kvm_run *run)
{
- if (!kvm_irqchip_in_kernel())
+ if (!kvm_irqchip_in_kernel()) {
kvm_set_cr8(env, cpu_get_apic_tpr(env->apic_state));
+ }
return 0;
}
@@ -1236,8 +1270,9 @@ int kvm_arch_has_work(CPUState *env)
{
if (((env->interrupt_request & CPU_INTERRUPT_HARD) &&
(env->eflags & IF_MASK)) ||
- (env->interrupt_request & CPU_INTERRUPT_NMI))
+ (env->interrupt_request & CPU_INTERRUPT_NMI)) {
return 1;
+ }
return 0;
}
@@ -1253,8 +1288,9 @@ int kvm_arch_try_push_interrupts(void *opaque)
irq = cpu_get_pic_interrupt(env);
if (irq >= 0) {
r = kvm_inject_irq(env, irq);
- if (r < 0)
+ if (r < 0) {
printf("cpu %d fail inject %x\n", env->cpu_index, irq);
+ }
}
}
@@ -1267,13 +1303,15 @@ void kvm_arch_push_nmi(void *opaque)
CPUState *env = cpu_single_env;
int r;
- if (likely(!(env->interrupt_request & CPU_INTERRUPT_NMI)))
+ if (likely(!(env->interrupt_request & CPU_INTERRUPT_NMI))) {
return;
+ }
env->interrupt_request &= ~CPU_INTERRUPT_NMI;
r = kvm_inject_nmi(env);
- if (r < 0)
+ if (r < 0) {
printf("cpu %d fail inject NMI\n", env->cpu_index);
+ }
}
#endif /* KVM_CAP_USER_NMI */
@@ -1286,8 +1324,9 @@ static int kvm_reset_msrs(CPUState *env)
int n;
struct kvm_msr_entry *msrs = msr_data.entries;
- if (!kvm_msr_list)
+ if (!kvm_msr_list) {
return -1;
+ }
for (n = 0; n < kvm_msr_list->nmsrs; n++) {
kvm_msr_entry_set(&msrs[n], kvm_msr_list->indices[n], 0);
@@ -1324,16 +1363,19 @@ int kvm_arch_init_irq_routing(void)
if (kvm_irqchip && kvm_has_gsi_routing(kvm_context)) {
kvm_clear_gsi_routes(kvm_context);
for (i = 0; i < 8; ++i) {
- if (i == 2)
+ if (i == 2) {
continue;
+ }
r = kvm_add_irq_route(kvm_context, i, KVM_IRQCHIP_PIC_MASTER, i);
- if (r < 0)
+ if (r < 0) {
return r;
+ }
}
for (i = 8; i < 16; ++i) {
r = kvm_add_irq_route(kvm_context, i, KVM_IRQCHIP_PIC_SLAVE, i - 8);
- if (r < 0)
+ if (r < 0) {
return r;
+ }
}
for (i = 0; i < 24; ++i) {
if (i == 0) {
@@ -1341,8 +1383,9 @@ int kvm_arch_init_irq_routing(void)
} else if (i != 2) {
r = kvm_add_irq_route(kvm_context, i, KVM_IRQCHIP_IOAPIC, i);
}
- if (r < 0)
+ if (r < 0) {
return r;
+ }
}
kvm_commit_irq_routes(kvm_context);
}
--
1.7.1
^ permalink raw reply related [flat|nested] 7+ messages in thread* [PATCH 4/4] qemu-kvm.c: add braces where appropriate
2010-09-05 12:13 [PATCH 0/4] Apply some CODING_STYLE to qemu-kvm*.c Avi Kivity
` (2 preceding siblings ...)
2010-09-05 12:13 ` [PATCH 3/4] qemu-kvm-x86.c: add braces where appropriate Avi Kivity
@ 2010-09-05 12:13 ` Avi Kivity
2010-09-05 12:29 ` [PATCH 0/4] Apply some CODING_STYLE to qemu-kvm*.c Avi Kivity
2010-09-06 20:01 ` Marcelo Tosatti
5 siblings, 0 replies; 7+ messages in thread
From: Avi Kivity @ 2010-09-05 12:13 UTC (permalink / raw)
To: Marcelo Tosatti, kvm
Adjust to comply with CODING_STYLE, at least where braces are concerned.
Signed-off-by: Avi Kivity <avi@redhat.com>
---
qemu-kvm.c | 174 ++++++++++++++++++++++++++++++++++++++---------------------
1 files changed, 112 insertions(+), 62 deletions(-)
diff --git a/qemu-kvm.c b/qemu-kvm.c
index c9818de..36f3a2e 100644
--- a/qemu-kvm.c
+++ b/qemu-kvm.c
@@ -201,8 +201,9 @@ int kvm_init(int smp_cpus)
kvm_context->max_gsi = gsi_bits;
/* Mark any over-allocated bits as already in use */
- for (i = gsi_count; i < gsi_bits; i++)
+ for (i = gsi_count; i < gsi_bits; i++) {
set_gsi(kvm_context, i);
+ }
}
kvm_cpu_register_phys_memory_client();
@@ -296,8 +297,9 @@ static int kvm_set_boot_vcpu_id(kvm_context_t kvm, uint32_t id)
{
#ifdef KVM_CAP_SET_BOOT_CPU_ID
int r = kvm_ioctl(kvm_state, KVM_CHECK_EXTENSION, KVM_CAP_SET_BOOT_CPU_ID);
- if (r > 0)
+ if (r > 0) {
return kvm_vm_ioctl(kvm_state, KVM_SET_BOOT_CPU_ID, id);
+ }
return -ENOSYS;
#else
return -ENOSYS;
@@ -352,8 +354,9 @@ void kvm_create_irqchip(kvm_context_t kvm)
#if defined(KVM_CAP_IRQ_INJECT_STATUS) && defined(KVM_IRQ_LINE_STATUS)
r = kvm_ioctl(kvm_state, KVM_CHECK_EXTENSION,
KVM_CAP_IRQ_INJECT_STATUS);
- if (r > 0)
+ if (r > 0) {
kvm->irqchip_inject_ioctl = KVM_IRQ_LINE_STATUS;
+ }
#endif
kvm->irqchip_in_kernel = 1;
} else
@@ -369,17 +372,22 @@ int kvm_create(kvm_context_t kvm, unsigned long phys_mem_bytes, void **vm_mem)
int r, i;
r = kvm_create_vm(kvm);
- if (r < 0)
+ if (r < 0) {
return r;
+ }
r = kvm_arch_create(kvm, phys_mem_bytes, vm_mem);
- if (r < 0)
+ if (r < 0) {
return r;
- for (i = 0; i < ARRAY_SIZE(kvm_state->slots); i++)
+ }
+ for (i = 0; i < ARRAY_SIZE(kvm_state->slots); i++) {
kvm_state->slots[i].slot = i;
+ }
r = kvm_create_default_phys_mem(kvm, phys_mem_bytes, vm_mem);
- if (r < 0)
+ if (r < 0) {
return r;
+ }
+
kvm_create_irqchip(kvm);
return 0;
@@ -392,13 +400,15 @@ int kvm_set_irq_level(kvm_context_t kvm, int irq, int level, int *status)
struct kvm_irq_level event;
int r;
- if (!kvm->irqchip_in_kernel)
+ if (!kvm->irqchip_in_kernel) {
return 0;
+ }
event.level = level;
event.irq = irq;
r = kvm_vm_ioctl(kvm_state, kvm->irqchip_inject_ioctl, &event);
- if (r < 0)
+ if (r < 0) {
perror("kvm_set_irq_level");
+ }
if (status) {
#ifdef KVM_CAP_IRQ_INJECT_STATUS
@@ -416,8 +426,9 @@ int kvm_get_irqchip(kvm_context_t kvm, struct kvm_irqchip *chip)
{
int r;
- if (!kvm->irqchip_in_kernel)
+ if (!kvm->irqchip_in_kernel) {
return 0;
+ }
r = kvm_vm_ioctl(kvm_state, KVM_GET_IRQCHIP, chip);
if (r < 0) {
perror("kvm_get_irqchip\n");
@@ -429,8 +440,9 @@ int kvm_set_irqchip(kvm_context_t kvm, struct kvm_irqchip *chip)
{
int r;
- if (!kvm->irqchip_in_kernel)
+ if (!kvm->irqchip_in_kernel) {
return 0;
+ }
r = kvm_vm_ioctl(kvm_state, KVM_SET_IRQCHIP, chip);
if (r < 0) {
perror("kvm_set_irqchip\n");
@@ -487,8 +499,9 @@ int kvm_get_mpstate(CPUState *env, struct kvm_mp_state *mp_state)
int r;
r = kvm_ioctl(kvm_state, KVM_CHECK_EXTENSION, KVM_CAP_MP_STATE);
- if (r > 0)
+ if (r > 0) {
return kvm_vcpu_ioctl(env, KVM_GET_MP_STATE, mp_state);
+ }
return -ENOSYS;
}
@@ -497,8 +510,9 @@ int kvm_set_mpstate(CPUState *env, struct kvm_mp_state *mp_state)
int r;
r = kvm_ioctl(kvm_state, KVM_CHECK_EXTENSION, KVM_CAP_MP_STATE);
- if (r > 0)
+ if (r > 0) {
return kvm_vcpu_ioctl(env, KVM_SET_MP_STATE, mp_state);
+ }
return -ENOSYS;
}
#endif
@@ -534,8 +548,9 @@ static int handle_mmio(CPUState *env)
void *data = kvm_run->mmio.data;
/* hack: Red Hat 7.1 generates these weird accesses. */
- if ((addr > 0xa0000 - 4 && addr <= 0xa0000) && kvm_run->mmio.len == 3)
+ if ((addr > 0xa0000 - 4 && addr <= 0xa0000) && kvm_run->mmio.len == 3) {
return 0;
+ }
cpu_physical_memory_rw(addr, data, kvm_run->mmio.len, kvm_run->mmio.is_write);
return 0;
@@ -596,13 +611,15 @@ int kvm_run(CPUState *env)
}
push_nmi(kvm);
#if !defined(__s390__)
- if (!kvm->irqchip_in_kernel)
+ if (!kvm->irqchip_in_kernel) {
run->request_interrupt_window = kvm_arch_try_push_interrupts(env);
+ }
#endif
r = pre_kvm_run(kvm, env);
- if (r)
+ if (r) {
return r;
+ }
if (env->exit_request) {
env->exit_request = 0;
pthread_kill(env->kvm_cpu_state.thread, SIG_IPI);
@@ -684,9 +701,10 @@ int kvm_run(CPUState *env)
break;
}
}
- more:
- if (!r)
+more:
+ if (!r) {
goto again;
+ }
return r;
}
@@ -822,13 +840,15 @@ int kvm_add_routing_entry(kvm_context_t kvm,
if (kvm->irq_routes->nr == kvm->nr_allocated_irq_routes) {
n = kvm->nr_allocated_irq_routes * 2;
- if (n < 64)
+ if (n < 64) {
n = 64;
+ }
size = sizeof(struct kvm_irq_routing);
size += n * sizeof(*new);
z = realloc(kvm->irq_routes, size);
- if (!z)
+ if (!z) {
return -ENOMEM;
+ }
kvm->nr_allocated_irq_routes = n;
kvm->irq_routes = z;
}
@@ -910,8 +930,9 @@ int kvm_del_routing_entry(kvm_context_t kvm,
if (e->gsi == gsi)
break;
}
- if (i == kvm->irq_routes->nr)
+ if (i == kvm->irq_routes->nr) {
clear_gsi(kvm, gsi);
+ }
return 0;
}
@@ -1001,8 +1022,9 @@ int kvm_get_irq_route_gsi(kvm_context_t kvm)
/* Return the lowest unused GSI in the bitmap */
for (i = 0; i < kvm->max_gsi / 32; i++) {
bit = ffs(~buf[i]);
- if (!bit)
+ if (!bit) {
continue;
+ }
return bit - 1 + i * 32;
}
@@ -1048,8 +1070,9 @@ int kvm_irqfd(kvm_context_t kvm, int gsi, int flags)
return -ENOENT;
fd = eventfd(0, 0);
- if (fd < 0)
+ if (fd < 0) {
return -errno;
+ }
r = _kvm_irqfd(kvm, fd, gsi, 0);
if (r < 0) {
@@ -1132,18 +1155,20 @@ static void sigbus_handler(int n, struct qemu_signalfd_siginfo *siginfo,
kvm_inject_x86_mce(first_cpu, 9, status,
MCG_STATUS_MCIP | MCG_STATUS_RIPV, paddr,
(MCM_ADDR_PHYS << 6) | 0xc, 1);
- for (cenv = first_cpu->next_cpu; cenv != NULL; cenv = cenv->next_cpu)
+ for (cenv = first_cpu->next_cpu; cenv != NULL; cenv = cenv->next_cpu) {
kvm_inject_x86_mce(cenv, 1, MCI_STATUS_VAL | MCI_STATUS_UC,
MCG_STATUS_MCIP | MCG_STATUS_RIPV, 0, 0, 1);
+ }
} else
#endif
{
- if (siginfo->ssi_code == BUS_MCEERR_AO)
+ if (siginfo->ssi_code == BUS_MCEERR_AO) {
return;
- else if (siginfo->ssi_code == BUS_MCEERR_AR)
+ } else if (siginfo->ssi_code == BUS_MCEERR_AR) {
hardware_memory_error();
- else
+ } else {
sigbus_reraise();
+ }
}
}
@@ -1158,17 +1183,19 @@ static void on_vcpu(CPUState *env, void (*func)(void *data), void *data)
wi.func = func;
wi.data = data;
- if (!env->kvm_cpu_state.queued_work_first)
+ if (!env->kvm_cpu_state.queued_work_first) {
env->kvm_cpu_state.queued_work_first = &wi;
- else
+ } else {
env->kvm_cpu_state.queued_work_last->next = &wi;
+ }
env->kvm_cpu_state.queued_work_last = &wi;
wi.next = NULL;
wi.done = false;
pthread_kill(env->kvm_cpu_state.thread, SIG_IPI);
- while (!wi.done)
+ while (!wi.done) {
qemu_cond_wait(&qemu_work_cond);
+ }
}
static void do_kvm_cpu_synchronize_state(void *_env)
@@ -1183,8 +1210,9 @@ static void do_kvm_cpu_synchronize_state(void *_env)
void kvm_cpu_synchronize_state(CPUState *env)
{
- if (!env->kvm_vcpu_dirty)
+ if (!env->kvm_vcpu_dirty) {
on_vcpu(env, do_kvm_cpu_synchronize_state, env);
+ }
}
void kvm_cpu_synchronize_post_reset(CPUState *env)
@@ -1214,19 +1242,22 @@ void kvm_update_interrupt_request(CPUState *env)
int signal = 0;
if (env) {
- if (!current_env || !current_env->created)
+ if (!current_env || !current_env->created) {
signal = 1;
+ }
/*
* Testing for created here is really redundant
*/
if (current_env && current_env->created &&
- env != current_env && !env->kvm_cpu_state.signalled)
+ env != current_env && !env->kvm_cpu_state.signalled) {
signal = 1;
+ }
if (signal) {
env->kvm_cpu_state.signalled = 1;
- if (env->kvm_cpu_state.thread)
+ if (env->kvm_cpu_state.thread) {
pthread_kill(env->kvm_cpu_state.thread, SIG_IPI);
+ }
}
}
}
@@ -1253,8 +1284,9 @@ static void flush_queued_work(CPUState *env)
{
struct qemu_work_item *wi;
- if (!env->kvm_cpu_state.queued_work_first)
+ if (!env->kvm_cpu_state.queued_work_first) {
return;
+ }
while ((wi = env->kvm_cpu_state.queued_work_first)) {
env->kvm_cpu_state.queued_work_first = wi->next;
@@ -1273,8 +1305,9 @@ static int kvm_mce_in_exception(CPUState *env)
int r;
r = kvm_get_msrs(env, &msr_mcg_status, 1);
- if (r == -1 || r == 0)
+ if (r == -1 || r == 0) {
return -1;
+ }
return !!(msr_mcg_status.data & MCG_STATUS_MCIP);
}
@@ -1303,10 +1336,11 @@ static void kvm_on_sigbus(CPUState *env, siginfo_t *siginfo)
* this SRAO MCE
*/
r = kvm_mce_in_exception(env);
- if (r == -1)
+ if (r == -1) {
fprintf(stderr, "Failed to get MCE status\n");
- else if (r)
+ } else if (r) {
return;
+ }
/* Fake an Intel architectural Memory scrubbing UCR */
mce.status = MCI_STATUS_VAL | MCI_STATUS_UC | MCI_STATUS_EN
| MCI_STATUS_MISCV | MCI_STATUS_ADDRV | MCI_STATUS_S
@@ -1318,10 +1352,11 @@ static void kvm_on_sigbus(CPUState *env, siginfo_t *siginfo)
fprintf(stderr, "Hardware memory error for memory used by "
"QEMU itself instaed of guest system!\n");
/* Hope we are lucky for AO MCE */
- if (siginfo->si_code == BUS_MCEERR_AO)
+ if (siginfo->si_code == BUS_MCEERR_AO) {
return;
- else
+ } else {
hardware_memory_error();
+ }
}
mce.addr = paddr;
r = kvm_set_mce(env, &mce);
@@ -1332,12 +1367,13 @@ static void kvm_on_sigbus(CPUState *env, siginfo_t *siginfo)
} else
#endif
{
- if (siginfo->si_code == BUS_MCEERR_AO)
+ if (siginfo->si_code == BUS_MCEERR_AO) {
return;
- else if (siginfo->si_code == BUS_MCEERR_AR)
+ } else if (siginfo->si_code == BUS_MCEERR_AR) {
hardware_memory_error();
- else
+ } else {
sigbus_reraise();
+ }
}
}
@@ -1400,8 +1436,9 @@ static int all_threads_paused(void)
CPUState *penv = first_cpu;
while (penv) {
- if (penv->stop)
+ if (penv->stop) {
return 0;
+ }
penv = (CPUState *) penv->next_cpu;
}
@@ -1424,8 +1461,9 @@ static void pause_all_threads(void)
penv = (CPUState *) penv->next_cpu;
}
- while (!all_threads_paused())
+ while (!all_threads_paused()) {
qemu_cond_wait(&qemu_pause_cond);
+ }
}
static void resume_all_threads(void)
@@ -1444,10 +1482,11 @@ static void resume_all_threads(void)
static void kvm_vm_state_change_handler(void *context, int running, int reason)
{
- if (running)
+ if (running) {
resume_all_threads();
- else
+ } else {
pause_all_threads();
+ }
}
static void setup_kernel_sigmask(CPUState *env)
@@ -1532,8 +1571,9 @@ static void *ap_main_loop(void *_env)
pthread_cond_signal(&qemu_vcpu_cond);
/* and wait for machine initialization */
- while (!qemu_system_ready)
+ while (!qemu_system_ready) {
qemu_cond_wait(&qemu_system_cond);
+ }
/* re-initialize cpu_single_env after re-acquiring qemu_mutex */
cpu_single_env = env;
@@ -1546,8 +1586,9 @@ int kvm_init_vcpu(CPUState *env)
{
pthread_create(&env->kvm_cpu_state.thread, NULL, ap_main_loop, env);
- while (env->created == 0)
+ while (env->created == 0) {
qemu_cond_wait(&qemu_vcpu_cond);
+ }
return 0;
}
@@ -1599,8 +1640,9 @@ void qemu_kvm_notify_work(void)
static uint64_t val = 1;
ssize_t ret;
- if (io_thread_fd == -1)
+ if (io_thread_fd == -1) {
return;
+ }
do {
ret = write(io_thread_fd, &val, sizeof(val));
@@ -1631,8 +1673,9 @@ static void sigfd_handler(void *opaque)
len = read(fd, &info, sizeof(info));
} while (len == -1 && errno == EINTR);
- if (len == -1 && errno == EAGAIN)
+ if (len == -1 && errno == EAGAIN) {
break;
+ }
if (len != sizeof(info)) {
printf("read from sigfd returned %zd: %m\n", len);
@@ -1640,12 +1683,12 @@ static void sigfd_handler(void *opaque)
}
sigaction(info.ssi_signo, NULL, &action);
- if ((action.sa_flags & SA_SIGINFO) && action.sa_sigaction)
+ if ((action.sa_flags & SA_SIGINFO) && action.sa_sigaction) {
action.sa_sigaction(info.ssi_signo,
(siginfo_t *)&info, NULL);
- else if (action.sa_handler)
+ } else if (action.sa_handler) {
action.sa_handler(info.ssi_signo);
-
+ }
}
}
@@ -1712,8 +1755,9 @@ int kvm_main_loop(void)
monitor_protocol_event(QEVENT_SHUTDOWN, NULL);
if (qemu_no_shutdown()) {
vm_stop(0);
- } else
+ } else {
break;
+ }
} else if (qemu_powerdown_requested()) {
monitor_protocol_event(QEVENT_POWERDOWN, NULL);
qemu_irq_raise(qemu_system_powerdown);
@@ -1840,14 +1884,16 @@ static void kvm_mutex_lock(void)
void qemu_mutex_unlock_iothread(void)
{
- if (kvm_enabled())
+ if (kvm_enabled()) {
kvm_mutex_unlock();
+ }
}
void qemu_mutex_lock_iothread(void)
{
- if (kvm_enabled())
+ if (kvm_enabled()) {
kvm_mutex_lock();
+ }
}
#ifdef CONFIG_KVM_DEVICE_ASSIGNMENT
@@ -1875,8 +1921,9 @@ void kvm_remove_ioperm_data(unsigned long start_port, unsigned long num)
void kvm_ioperm(CPUState *env, void *data)
{
- if (kvm_enabled() && qemu_system_ready)
+ if (kvm_enabled() && qemu_system_ready) {
on_vcpu(env, kvm_arch_do_ioperm, data);
+ }
}
#endif
@@ -1901,15 +1948,17 @@ static void kvm_do_inject_x86_mce(void *_data)
/* If there is an MCE excpetion being processed, ignore this SRAO MCE */
r = kvm_mce_in_exception(data->env);
- if (r == -1)
+ if (r == -1) {
fprintf(stderr, "Failed to get MCE status\n");
- else if (r && !(data->mce->status & MCI_STATUS_AR))
+ } else if (r && !(data->mce->status & MCI_STATUS_AR)) {
return;
+ }
r = kvm_set_mce(data->env, data->mce);
if (r < 0) {
perror("kvm_set_mce FAILED");
- if (data->abort_on_error)
+ if (data->abort_on_error) {
abort();
+ }
}
}
#endif
@@ -1938,8 +1987,9 @@ void kvm_inject_x86_mce(CPUState *cenv, int bank, uint64_t status,
}
on_vcpu(cenv, kvm_do_inject_x86_mce, &data);
#else
- if (abort_on_error)
+ if (abort_on_error) {
abort();
+ }
#endif
}
#endif
--
1.7.1
^ permalink raw reply related [flat|nested] 7+ messages in thread