Commit 89400f06 authored by Paolo Bonzini's avatar Paolo Bonzini
Browse files

Merge tag 'kvm-x86-apic-6.17' of https://github.com/kvm-x86/linux into HEAD 

KVM local APIC changes for 6.17

Extract many of KVM's helpers for accessing architectural local APIC state
to common x86 so that they can be shared by guest-side code for Secure AVIC.
parents d7f4aac2 b95a9d31

arch/x86/include/asm/apic.h

+64 −2
Original line number Diff line number Diff line
@@ -488,11 +488,14 @@ static inline void apic_setup_apic_calls(void) { } 


extern void apic_ack_irq(struct irq_data *data);



#define APIC_VECTOR_TO_BIT_NUMBER(v) ((unsigned int)(v) % 32)

#define APIC_VECTOR_TO_REG_OFFSET(v) ((unsigned int)(v) / 32 * 0x10)



static inline bool lapic_vector_set_in_irr(unsigned int vector)

{

	u32 irr = apic_read(APIC_IRR + (vector / 32 * 0x10));

	u32 irr = apic_read(APIC_IRR + APIC_VECTOR_TO_REG_OFFSET(vector));



	return !!(irr & (1U << (vector % 32)));

	return !!(irr & (1U << APIC_VECTOR_TO_BIT_NUMBER(vector)));

}



static inline bool is_vector_pending(unsigned int vector)
@@ -500,6 +503,65 @@ static inline bool is_vector_pending(unsigned int vector) 
	return lapic_vector_set_in_irr(vector) || pi_pending_this_cpu(vector);

}



#define MAX_APIC_VECTOR			256

#define APIC_VECTORS_PER_REG		32



/*

 * Vector states are maintained by APIC in 32-bit registers that are

 * 16 bytes aligned. The status of each vector is kept in a single

 * bit.

 */

static inline int apic_find_highest_vector(void *bitmap)

{

	int vec;

	u32 *reg;



	for (vec = MAX_APIC_VECTOR - APIC_VECTORS_PER_REG; vec >= 0; vec -= APIC_VECTORS_PER_REG) {

		reg = bitmap + APIC_VECTOR_TO_REG_OFFSET(vec);

		if (*reg)

			return __fls(*reg) + vec;

	}



	return -1;

}



static inline u32 apic_get_reg(void *regs, int reg)

{

	return *((u32 *) (regs + reg));

}



static inline void apic_set_reg(void *regs, int reg, u32 val)

{

	*((u32 *) (regs + reg)) = val;

}



static __always_inline u64 apic_get_reg64(void *regs, int reg)

{

	BUILD_BUG_ON(reg != APIC_ICR);

	return *((u64 *) (regs + reg));

}



static __always_inline void apic_set_reg64(void *regs, int reg, u64 val)

{

	BUILD_BUG_ON(reg != APIC_ICR);

	*((u64 *) (regs + reg)) = val;

}



static inline void apic_clear_vector(int vec, void *bitmap)

{

	clear_bit(APIC_VECTOR_TO_BIT_NUMBER(vec), bitmap + APIC_VECTOR_TO_REG_OFFSET(vec));

}



static inline void apic_set_vector(int vec, void *bitmap)

{

	set_bit(APIC_VECTOR_TO_BIT_NUMBER(vec), bitmap + APIC_VECTOR_TO_REG_OFFSET(vec));

}



static inline int apic_test_vector(int vec, void *bitmap)

{

	return test_bit(APIC_VECTOR_TO_BIT_NUMBER(vec), bitmap + APIC_VECTOR_TO_REG_OFFSET(vec));

}



/*

 * Warm reset vector position:

 */

arch/x86/kvm/lapic.c

+26 −71
Original line number Diff line number Diff line
@@ -27,6 +27,7 @@ 
#include <linux/export.h>

#include <linux/math64.h>

#include <linux/slab.h>

#include <asm/apic.h>

#include <asm/processor.h>

#include <asm/mce.h>

#include <asm/msr.h>
@@ -55,9 +56,6 @@ 
/* 14 is the version for Xeon and Pentium 8.4.8*/

#define APIC_VERSION			0x14UL

#define LAPIC_MMIO_LENGTH		(1 << 12)

/* followed define is not in apicdef.h */

#define MAX_APIC_VECTOR			256

#define APIC_VECTORS_PER_REG		32



/*

 * Enable local APIC timer advancement (tscdeadline mode only) with adaptive
@@ -79,42 +77,20 @@ module_param(lapic_timer_advance, bool, 0444); 
static int kvm_lapic_msr_read(struct kvm_lapic *apic, u32 reg, u64 *data);

static int kvm_lapic_msr_write(struct kvm_lapic *apic, u32 reg, u64 data);



static inline void __kvm_lapic_set_reg(char *regs, int reg_off, u32 val)

{

	*((u32 *) (regs + reg_off)) = val;

}



static inline void kvm_lapic_set_reg(struct kvm_lapic *apic, int reg_off, u32 val)

{

	__kvm_lapic_set_reg(apic->regs, reg_off, val);

}



static __always_inline u64 __kvm_lapic_get_reg64(char *regs, int reg)

{

	BUILD_BUG_ON(reg != APIC_ICR);

	return *((u64 *) (regs + reg));

	apic_set_reg(apic->regs, reg_off, val);

}



static __always_inline u64 kvm_lapic_get_reg64(struct kvm_lapic *apic, int reg)

{

	return __kvm_lapic_get_reg64(apic->regs, reg);

}



static __always_inline void __kvm_lapic_set_reg64(char *regs, int reg, u64 val)

{

	BUILD_BUG_ON(reg != APIC_ICR);

	*((u64 *) (regs + reg)) = val;

	return apic_get_reg64(apic->regs, reg);

}



static __always_inline void kvm_lapic_set_reg64(struct kvm_lapic *apic,

						int reg, u64 val)

{

	__kvm_lapic_set_reg64(apic->regs, reg, val);

}



static inline int apic_test_vector(int vec, void *bitmap)

{

	return test_bit(VEC_POS(vec), (bitmap) + REG_POS(vec));

	apic_set_reg64(apic->regs, reg, val);

}



bool kvm_apic_pending_eoi(struct kvm_vcpu *vcpu, int vector)
@@ -125,16 +101,6 @@ bool kvm_apic_pending_eoi(struct kvm_vcpu *vcpu, int vector) 
		apic_test_vector(vector, apic->regs + APIC_IRR);

}



static inline int __apic_test_and_set_vector(int vec, void *bitmap)

{

	return __test_and_set_bit(VEC_POS(vec), (bitmap) + REG_POS(vec));

}



static inline int __apic_test_and_clear_vector(int vec, void *bitmap)

{

	return __test_and_clear_bit(VEC_POS(vec), (bitmap) + REG_POS(vec));

}



__read_mostly DEFINE_STATIC_KEY_FALSE(kvm_has_noapic_vcpu);

EXPORT_SYMBOL_GPL(kvm_has_noapic_vcpu);
@@ -626,21 +592,6 @@ static const unsigned int apic_lvt_mask[KVM_APIC_MAX_NR_LVT_ENTRIES] = { 
	[LVT_CMCI] = LVT_MASK | APIC_MODE_MASK

};



static int find_highest_vector(void *bitmap)

{

	int vec;

	u32 *reg;



	for (vec = MAX_APIC_VECTOR - APIC_VECTORS_PER_REG;

	     vec >= 0; vec -= APIC_VECTORS_PER_REG) {

		reg = bitmap + REG_POS(vec);

		if (*reg)

			return __fls(*reg) + vec;

	}



	return -1;

}



static u8 count_vectors(void *bitmap)

{

	int vec;
@@ -648,7 +599,7 @@ static u8 count_vectors(void *bitmap) 
	u8 count = 0;



	for (vec = 0; vec < MAX_APIC_VECTOR; vec += APIC_VECTORS_PER_REG) {

		reg = bitmap + REG_POS(vec);

		reg = bitmap + APIC_VECTOR_TO_REG_OFFSET(vec);

		count += hweight32(*reg);

	}
@@ -706,7 +657,7 @@ EXPORT_SYMBOL_GPL(kvm_apic_update_irr); 


static inline int apic_search_irr(struct kvm_lapic *apic)

{

	return find_highest_vector(apic->regs + APIC_IRR);

	return apic_find_highest_vector(apic->regs + APIC_IRR);

}



static inline int apic_find_highest_irr(struct kvm_lapic *apic)
@@ -729,10 +680,10 @@ static inline int apic_find_highest_irr(struct kvm_lapic *apic) 
static inline void apic_clear_irr(int vec, struct kvm_lapic *apic)

{

	if (unlikely(apic->apicv_active)) {

		kvm_lapic_clear_vector(vec, apic->regs + APIC_IRR);

		apic_clear_vector(vec, apic->regs + APIC_IRR);

	} else {

		apic->irr_pending = false;

		kvm_lapic_clear_vector(vec, apic->regs + APIC_IRR);

		apic_clear_vector(vec, apic->regs + APIC_IRR);

		if (apic_search_irr(apic) != -1)

			apic->irr_pending = true;

	}
@@ -744,9 +695,15 @@ void kvm_apic_clear_irr(struct kvm_vcpu *vcpu, int vec) 
}

EXPORT_SYMBOL_GPL(kvm_apic_clear_irr);



static void *apic_vector_to_isr(int vec, struct kvm_lapic *apic)

{

	return apic->regs + APIC_ISR + APIC_VECTOR_TO_REG_OFFSET(vec);

}



static inline void apic_set_isr(int vec, struct kvm_lapic *apic)

{

	if (__apic_test_and_set_vector(vec, apic->regs + APIC_ISR))

	if (__test_and_set_bit(APIC_VECTOR_TO_BIT_NUMBER(vec),

			       apic_vector_to_isr(vec, apic)))

		return;



	/*
@@ -781,7 +738,7 @@ static inline int apic_find_highest_isr(struct kvm_lapic *apic) 
	if (likely(apic->highest_isr_cache != -1))

		return apic->highest_isr_cache;



	result = find_highest_vector(apic->regs + APIC_ISR);

	result = apic_find_highest_vector(apic->regs + APIC_ISR);

	ASSERT(result == -1 || result >= 16);



	return result;
@@ -789,7 +746,8 @@ static inline int apic_find_highest_isr(struct kvm_lapic *apic) 


static inline void apic_clear_isr(int vec, struct kvm_lapic *apic)

{

	if (!__apic_test_and_clear_vector(vec, apic->regs + APIC_ISR))

	if (!__test_and_clear_bit(APIC_VECTOR_TO_BIT_NUMBER(vec),

				  apic_vector_to_isr(vec, apic)))

		return;



	/*
@@ -1332,11 +1290,9 @@ static int __apic_accept_irq(struct kvm_lapic *apic, int delivery_mode, 


		if (apic_test_vector(vector, apic->regs + APIC_TMR) != !!trig_mode) {

			if (trig_mode)

				kvm_lapic_set_vector(vector,

						     apic->regs + APIC_TMR);

				apic_set_vector(vector, apic->regs + APIC_TMR);

			else

				kvm_lapic_clear_vector(vector,

						       apic->regs + APIC_TMR);

				apic_clear_vector(vector, apic->regs + APIC_TMR);

		}



		kvm_x86_call(deliver_interrupt)(apic, delivery_mode,
@@ -3086,12 +3042,12 @@ static int kvm_apic_state_fixup(struct kvm_vcpu *vcpu, 


		if (!kvm_x86_ops.x2apic_icr_is_split) {

			if (set) {

				icr = __kvm_lapic_get_reg(s->regs, APIC_ICR) |

				      (u64)__kvm_lapic_get_reg(s->regs, APIC_ICR2) << 32;

				__kvm_lapic_set_reg64(s->regs, APIC_ICR, icr);

				icr = apic_get_reg(s->regs, APIC_ICR) |

				      (u64)apic_get_reg(s->regs, APIC_ICR2) << 32;

				apic_set_reg64(s->regs, APIC_ICR, icr);

			} else {

				icr = __kvm_lapic_get_reg64(s->regs, APIC_ICR);

				__kvm_lapic_set_reg(s->regs, APIC_ICR2, icr >> 32);

				icr = apic_get_reg64(s->regs, APIC_ICR);

				apic_set_reg(s->regs, APIC_ICR2, icr >> 32);

			}

		}

	}
@@ -3107,8 +3063,7 @@ int kvm_apic_get_state(struct kvm_vcpu *vcpu, struct kvm_lapic_state *s) 
	 * Get calculated timer current count for remaining timer period (if

	 * any) and store it in the returned register set.

	 */

	__kvm_lapic_set_reg(s->regs, APIC_TMCCT,

			    __apic_read(vcpu->arch.apic, APIC_TMCCT));

	apic_set_reg(s->regs, APIC_TMCCT, __apic_read(vcpu->arch.apic, APIC_TMCCT));



	return kvm_apic_state_fixup(vcpu, s, false);

}

arch/x86/kvm/lapic.h

+4 −20
Original line number Diff line number Diff line
@@ -4,6 +4,8 @@ 


#include <kvm/iodev.h>



#include <asm/apic.h>



#include <linux/kvm_host.h>



#include "hyperv.h"
@@ -147,22 +149,9 @@ void kvm_lapic_exit(void); 


u64 kvm_lapic_readable_reg_mask(struct kvm_lapic *apic);



#define VEC_POS(v) ((v) & (32 - 1))

#define REG_POS(v) (((v) >> 5) << 4)



static inline void kvm_lapic_clear_vector(int vec, void *bitmap)

{

	clear_bit(VEC_POS(vec), (bitmap) + REG_POS(vec));

}



static inline void kvm_lapic_set_vector(int vec, void *bitmap)

{

	set_bit(VEC_POS(vec), (bitmap) + REG_POS(vec));

}



static inline void kvm_lapic_set_irr(int vec, struct kvm_lapic *apic)

{

	kvm_lapic_set_vector(vec, apic->regs + APIC_IRR);

	apic_set_vector(vec, apic->regs + APIC_IRR);

	/*

	 * irr_pending must be true if any interrupt is pending; set it after

	 * APIC_IRR to avoid race with apic_clear_irr
@@ -170,14 +159,9 @@ static inline void kvm_lapic_set_irr(int vec, struct kvm_lapic *apic) 
	apic->irr_pending = true;

}



static inline u32 __kvm_lapic_get_reg(char *regs, int reg_off)

{

	return *((u32 *) (regs + reg_off));

}



static inline u32 kvm_lapic_get_reg(struct kvm_lapic *apic, int reg_off)

{

	return __kvm_lapic_get_reg(apic->regs, reg_off);

	return apic_get_reg(apic->regs, reg_off);

}



DECLARE_STATIC_KEY_FALSE(kvm_has_noapic_vcpu);