Merge branch 'kvm-updates/2.6.34' of git://git.kernel.org/pub/scm/virt/kvm/kvm

+1 -1

arch/powerpc/kvm/44x_tlb.c

··· 440 440 unsigned int gtlb_index; 441 441 442 442 gtlb_index = kvmppc_get_gpr(vcpu, ra); 443 - if (gtlb_index > KVM44x_GUEST_TLB_SIZE) { 443 + if (gtlb_index >= KVM44x_GUEST_TLB_SIZE) { 444 444 printk("%s: index %d\n", __func__, gtlb_index); 445 445 kvmppc_dump_vcpu(vcpu); 446 446 return EMULATE_FAIL;

+4 -4

arch/x86/kvm/svm.c

··· 2067 2067 static int iret_interception(struct vcpu_svm *svm) 2068 2068 { 2069 2069 ++svm->vcpu.stat.nmi_window_exits; 2070 - svm->vmcb->control.intercept &= ~(1UL << INTERCEPT_IRET); 2070 + svm->vmcb->control.intercept &= ~(1ULL << INTERCEPT_IRET); 2071 2071 svm->vcpu.arch.hflags |= HF_IRET_MASK; 2072 2072 return 1; 2073 2073 } ··· 2479 2479 2480 2480 svm->vmcb->control.event_inj = SVM_EVTINJ_VALID | SVM_EVTINJ_TYPE_NMI; 2481 2481 vcpu->arch.hflags |= HF_NMI_MASK; 2482 - svm->vmcb->control.intercept |= (1UL << INTERCEPT_IRET); 2482 + svm->vmcb->control.intercept |= (1ULL << INTERCEPT_IRET); 2483 2483 ++vcpu->stat.nmi_injections; 2484 2484 } 2485 2485 ··· 2539 2539 2540 2540 if (masked) { 2541 2541 svm->vcpu.arch.hflags |= HF_NMI_MASK; 2542 - svm->vmcb->control.intercept |= (1UL << INTERCEPT_IRET); 2542 + svm->vmcb->control.intercept |= (1ULL << INTERCEPT_IRET); 2543 2543 } else { 2544 2544 svm->vcpu.arch.hflags &= ~HF_NMI_MASK; 2545 - svm->vmcb->control.intercept &= ~(1UL << INTERCEPT_IRET); 2545 + svm->vmcb->control.intercept &= ~(1ULL << INTERCEPT_IRET); 2546 2546 } 2547 2547 } 2548 2548

+1 -2

arch/x86/kvm/vmx.c

··· 2703 2703 return 0; 2704 2704 2705 2705 return !(vmcs_read32(GUEST_INTERRUPTIBILITY_INFO) & 2706 - (GUEST_INTR_STATE_STI | GUEST_INTR_STATE_MOV_SS | 2707 - GUEST_INTR_STATE_NMI)); 2706 + (GUEST_INTR_STATE_MOV_SS | GUEST_INTR_STATE_NMI)); 2708 2707 } 2709 2708 2710 2709 static bool vmx_get_nmi_mask(struct kvm_vcpu *vcpu)

+4

arch/x86/kvm/x86.c

··· 1712 1712 if (copy_from_user(cpuid_entries, entries, 1713 1713 cpuid->nent * sizeof(struct kvm_cpuid_entry))) 1714 1714 goto out_free; 1715 + vcpu_load(vcpu); 1715 1716 for (i = 0; i < cpuid->nent; i++) { 1716 1717 vcpu->arch.cpuid_entries[i].function = cpuid_entries[i].function; 1717 1718 vcpu->arch.cpuid_entries[i].eax = cpuid_entries[i].eax; ··· 1730 1729 r = 0; 1731 1730 kvm_apic_set_version(vcpu); 1732 1731 kvm_x86_ops->cpuid_update(vcpu); 1732 + vcpu_put(vcpu); 1733 1733 1734 1734 out_free: 1735 1735 vfree(cpuid_entries); ··· 1751 1749 if (copy_from_user(&vcpu->arch.cpuid_entries, entries, 1752 1750 cpuid->nent * sizeof(struct kvm_cpuid_entry2))) 1753 1751 goto out; 1752 + vcpu_load(vcpu); 1754 1753 vcpu->arch.cpuid_nent = cpuid->nent; 1755 1754 kvm_apic_set_version(vcpu); 1756 1755 kvm_x86_ops->cpuid_update(vcpu); 1756 + vcpu_put(vcpu); 1757 1757 return 0; 1758 1758 1759 1759 out:

+15 -15

virt/kvm/ioapic.c

··· 197 197 union kvm_ioapic_redirect_entry entry; 198 198 int ret = 1; 199 199 200 - mutex_lock(&ioapic->lock); 200 + spin_lock(&ioapic->lock); 201 201 if (irq >= 0 && irq < IOAPIC_NUM_PINS) { 202 202 entry = ioapic->redirtbl[irq]; 203 203 level ^= entry.fields.polarity; ··· 214 214 } 215 215 trace_kvm_ioapic_set_irq(entry.bits, irq, ret == 0); 216 216 } 217 - mutex_unlock(&ioapic->lock); 217 + spin_unlock(&ioapic->lock); 218 218 219 219 return ret; 220 220 } ··· 238 238 * is dropped it will be put into irr and will be delivered 239 239 * after ack notifier returns. 240 240 */ 241 - mutex_unlock(&ioapic->lock); 241 + spin_unlock(&ioapic->lock); 242 242 kvm_notify_acked_irq(ioapic->kvm, KVM_IRQCHIP_IOAPIC, i); 243 - mutex_lock(&ioapic->lock); 243 + spin_lock(&ioapic->lock); 244 244 245 245 if (trigger_mode != IOAPIC_LEVEL_TRIG) 246 246 continue; ··· 259 259 smp_rmb(); 260 260 if (!test_bit(vector, ioapic->handled_vectors)) 261 261 return; 262 - mutex_lock(&ioapic->lock); 262 + spin_lock(&ioapic->lock); 263 263 __kvm_ioapic_update_eoi(ioapic, vector, trigger_mode); 264 - mutex_unlock(&ioapic->lock); 264 + spin_unlock(&ioapic->lock); 265 265 } 266 266 267 267 static inline struct kvm_ioapic *to_ioapic(struct kvm_io_device *dev) ··· 287 287 ASSERT(!(addr & 0xf)); /* check alignment */ 288 288 289 289 addr &= 0xff; 290 - mutex_lock(&ioapic->lock); 290 + spin_lock(&ioapic->lock); 291 291 switch (addr) { 292 292 case IOAPIC_REG_SELECT: 293 293 result = ioapic->ioregsel; ··· 301 301 result = 0; 302 302 break; 303 303 } 304 - mutex_unlock(&ioapic->lock); 304 + spin_unlock(&ioapic->lock); 305 305 306 306 switch (len) { 307 307 case 8: ··· 338 338 } 339 339 340 340 addr &= 0xff; 341 - mutex_lock(&ioapic->lock); 341 + spin_lock(&ioapic->lock); 342 342 switch (addr) { 343 343 case IOAPIC_REG_SELECT: 344 344 ioapic->ioregsel = data; ··· 356 356 default: 357 357 break; 358 358 } 359 - mutex_unlock(&ioapic->lock); 359 + spin_unlock(&ioapic->lock); 360 360 return 0; 361 361 } 362 362 ··· 386 386 ioapic = kzalloc(sizeof(struct kvm_ioapic), GFP_KERNEL); 387 387 if (!ioapic) 388 388 return -ENOMEM; 389 - mutex_init(&ioapic->lock); 389 + spin_lock_init(&ioapic->lock); 390 390 kvm->arch.vioapic = ioapic; 391 391 kvm_ioapic_reset(ioapic); 392 392 kvm_iodevice_init(&ioapic->dev, &ioapic_mmio_ops); ··· 419 419 if (!ioapic) 420 420 return -EINVAL; 421 421 422 - mutex_lock(&ioapic->lock); 422 + spin_lock(&ioapic->lock); 423 423 memcpy(state, ioapic, sizeof(struct kvm_ioapic_state)); 424 - mutex_unlock(&ioapic->lock); 424 + spin_unlock(&ioapic->lock); 425 425 return 0; 426 426 } 427 427 ··· 431 431 if (!ioapic) 432 432 return -EINVAL; 433 433 434 - mutex_lock(&ioapic->lock); 434 + spin_lock(&ioapic->lock); 435 435 memcpy(ioapic, state, sizeof(struct kvm_ioapic_state)); 436 436 update_handled_vectors(ioapic); 437 - mutex_unlock(&ioapic->lock); 437 + spin_unlock(&ioapic->lock); 438 438 return 0; 439 439 }

+1 -1

virt/kvm/ioapic.h

··· 45 45 struct kvm_io_device dev; 46 46 struct kvm *kvm; 47 47 void (*ack_notifier)(void *opaque, int irq); 48 - struct mutex lock; 48 + spinlock_t lock; 49 49 DECLARE_BITMAP(handled_vectors, 256); 50 50 }; 51 51

Configure Feed

Configure Feed