Commit 8965c1c0 authored by Jeremy Fitzhardinge's avatar Jeremy Fitzhardinge Committed by Jeremy Fitzhardinge
Browse files

paravirt: clean up lazy mode handling 



Currently, the set_lazy_mode pv_op is overloaded with 5 functions:
 1. enter lazy cpu mode
 2. leave lazy cpu mode
 3. enter lazy mmu mode
 4. leave lazy mmu mode
 5. flush pending batched operations

This complicates each paravirt backend, since it needs to deal with
all the possible state transitions, handling flushing, etc. In
particular, flushing is quite distinct from the other 4 functions, and
seems to just cause complication.

This patch removes the set_lazy_mode operation, and adds "enter" and
"leave" lazy mode operations on mmu_ops and cpu_ops.  All the logic
associated with enter and leaving lazy states is now in common code
(basically BUG_ONs to make sure that no mode is current when entering
a lazy mode, and make sure that the mode is current when leaving).
Also, flush is handled in a common way, by simply leaving and
re-entering the lazy mode.

The result is that the Xen, lguest and VMI lazy mode implementations
are much simpler.

Signed-off-by: default avatarJeremy Fitzhardinge <jeremy@xensource.com>
Cc: Andi Kleen <ak@suse.de>
Cc: Zach Amsden <zach@vmware.com>
Cc: Rusty Russell <rusty@rustcorp.com.au>
Cc: Avi Kivity <avi@qumranet.com>
Cc: Anthony Liguory <aliguori@us.ibm.com>
Cc: "Glauber de Oliveira Costa" <glommer@gmail.com>
Cc: Jun Nakajima <jun.nakajima@intel.com>
parent 93b1eab3

arch/x86/kernel/paravirt_32.c

+53 −5
Original line number Diff line number Diff line
@@ -164,7 +164,6 @@ static void *get_call_destination(u8 type) 
{

	struct paravirt_patch_template tmpl = {

		.pv_init_ops = pv_init_ops,

		.pv_misc_ops = pv_misc_ops,

		.pv_time_ops = pv_time_ops,

		.pv_cpu_ops = pv_cpu_ops,

		.pv_irq_ops = pv_irq_ops,
@@ -282,6 +281,49 @@ int paravirt_disable_iospace(void) 
	return ret;

}



static DEFINE_PER_CPU(enum paravirt_lazy_mode, paravirt_lazy_mode) = PARAVIRT_LAZY_NONE;



static inline void enter_lazy(enum paravirt_lazy_mode mode)

{

	BUG_ON(x86_read_percpu(paravirt_lazy_mode) != PARAVIRT_LAZY_NONE);

	BUG_ON(preemptible());



	x86_write_percpu(paravirt_lazy_mode, mode);

}



void paravirt_leave_lazy(enum paravirt_lazy_mode mode)

{

	BUG_ON(x86_read_percpu(paravirt_lazy_mode) != mode);

	BUG_ON(preemptible());



	x86_write_percpu(paravirt_lazy_mode, PARAVIRT_LAZY_NONE);

}



void paravirt_enter_lazy_mmu(void)

{

	enter_lazy(PARAVIRT_LAZY_MMU);

}



void paravirt_leave_lazy_mmu(void)

{

	paravirt_leave_lazy(PARAVIRT_LAZY_MMU);

}



void paravirt_enter_lazy_cpu(void)

{

	enter_lazy(PARAVIRT_LAZY_CPU);

}



void paravirt_leave_lazy_cpu(void)

{

	paravirt_leave_lazy(PARAVIRT_LAZY_CPU);

}



enum paravirt_lazy_mode paravirt_get_lazy_mode(void)

{

	return x86_read_percpu(paravirt_lazy_mode);

}



struct pv_info pv_info = {

	.name = "bare hardware",

	.paravirt_enabled = 0,
@@ -347,6 +389,11 @@ struct pv_cpu_ops pv_cpu_ops = { 


	.set_iopl_mask = native_set_iopl_mask,

	.io_delay = native_io_delay,



	.lazy_mode = {

		.enter = paravirt_nop,

		.leave = paravirt_nop,

	},

};



struct pv_apic_ops pv_apic_ops = {
@@ -360,10 +407,6 @@ struct pv_apic_ops pv_apic_ops = { 
#endif

};



struct pv_misc_ops pv_misc_ops = {

	.set_lazy_mode = paravirt_nop,

};



struct pv_mmu_ops pv_mmu_ops = {

	.pagetable_setup_start = native_pagetable_setup_start,

	.pagetable_setup_done = native_pagetable_setup_done,
@@ -414,6 +457,11 @@ struct pv_mmu_ops pv_mmu_ops = { 
	.dup_mmap = paravirt_nop,

	.exit_mmap = paravirt_nop,

	.activate_mm = paravirt_nop,



	.lazy_mode = {

		.enter = paravirt_nop,

		.leave = paravirt_nop,

	},

};



EXPORT_SYMBOL_GPL(pv_time_ops);

arch/x86/kernel/vmi_32.c

+23 −16
Original line number Diff line number Diff line
@@ -552,24 +552,22 @@ vmi_startup_ipi_hook(int phys_apicid, unsigned long start_eip, 
}

#endif



static void vmi_set_lazy_mode(enum paravirt_lazy_mode mode)

static void vmi_enter_lazy_cpu(void)

{

	static DEFINE_PER_CPU(enum paravirt_lazy_mode, lazy_mode);



	if (!vmi_ops.set_lazy_mode)

		return;

	paravirt_enter_lazy_cpu();

	vmi_ops.set_lazy_mode(2);

}



	/* Modes should never nest or overlap */

	BUG_ON(__get_cpu_var(lazy_mode) && !(mode == PARAVIRT_LAZY_NONE ||

					     mode == PARAVIRT_LAZY_FLUSH));

static void vmi_enter_lazy_mmu(void)

{

	paravirt_enter_lazy_mmu();

	vmi_ops.set_lazy_mode(1);

}



	if (mode == PARAVIRT_LAZY_FLUSH) {

static void vmi_leave_lazy(void)

{

	paravirt_leave_lazy(paravirt_get_lazy_mode());

	vmi_ops.set_lazy_mode(0);

		vmi_ops.set_lazy_mode(__get_cpu_var(lazy_mode));

	} else {

		vmi_ops.set_lazy_mode(mode);

		__get_cpu_var(lazy_mode) = mode;

	}

}



static inline int __init check_vmi_rom(struct vrom_header *rom)
@@ -798,7 +796,16 @@ static inline int __init activate_vmi(void) 
	para_wrap(pv_cpu_ops.load_esp0, vmi_load_esp0, set_kernel_stack, UpdateKernelStack);

	para_fill(pv_cpu_ops.set_iopl_mask, SetIOPLMask);

	para_fill(pv_cpu_ops.io_delay, IODelay);

	para_wrap(pv_misc_ops.set_lazy_mode, vmi_set_lazy_mode, set_lazy_mode, SetLazyMode);



	para_wrap(pv_cpu_ops.lazy_mode.enter, vmi_enter_lazy_cpu,

		  set_lazy_mode, SetLazyMode);

	para_wrap(pv_cpu_ops.lazy_mode.leave, vmi_leave_lazy,

		  set_lazy_mode, SetLazyMode);



	para_wrap(pv_mmu_ops.lazy_mode.enter, vmi_enter_lazy_mmu,

		  set_lazy_mode, SetLazyMode);

	para_wrap(pv_mmu_ops.lazy_mode.leave, vmi_leave_lazy,

		  set_lazy_mode, SetLazyMode);



	/* user and kernel flush are just handled with different flags to FlushTLB */

	para_wrap(pv_mmu_ops.flush_tlb_user, vmi_flush_tlb_user, _flush_tlb, FlushTLB);

arch/x86/xen/enlighten.c

+12 −28
Original line number Diff line number Diff line
@@ -52,8 +52,6 @@ 


EXPORT_SYMBOL_GPL(hypercall_page);



DEFINE_PER_CPU(enum paravirt_lazy_mode, xen_lazy_mode);



DEFINE_PER_CPU(struct vcpu_info *, xen_vcpu);

DEFINE_PER_CPU(struct vcpu_info, xen_vcpu_info);

DEFINE_PER_CPU(unsigned long, xen_cr3);
@@ -249,29 +247,10 @@ static void xen_halt(void) 
		xen_safe_halt();

}



static void xen_set_lazy_mode(enum paravirt_lazy_mode mode)

static void xen_leave_lazy(void)

{

	BUG_ON(preemptible());



	switch (mode) {

	case PARAVIRT_LAZY_NONE:

		BUG_ON(x86_read_percpu(xen_lazy_mode) == PARAVIRT_LAZY_NONE);

		break;



	case PARAVIRT_LAZY_MMU:

	case PARAVIRT_LAZY_CPU:

		BUG_ON(x86_read_percpu(xen_lazy_mode) != PARAVIRT_LAZY_NONE);

		break;



	case PARAVIRT_LAZY_FLUSH:

		/* flush if necessary, but don't change state */

		if (x86_read_percpu(xen_lazy_mode) != PARAVIRT_LAZY_NONE)

	paravirt_leave_lazy(paravirt_get_lazy_mode());

	xen_mc_flush();

		return;

	}



	xen_mc_flush();

	x86_write_percpu(xen_lazy_mode, mode);

}



static unsigned long xen_store_tr(void)
@@ -358,7 +337,7 @@ static void xen_load_tls(struct thread_struct *t, unsigned int cpu) 
	 * loaded properly.  This will go away as soon as Xen has been

	 * modified to not save/restore %gs for normal hypercalls.

	 */

	if (xen_get_lazy_mode() == PARAVIRT_LAZY_CPU)

	if (paravirt_get_lazy_mode() == PARAVIRT_LAZY_CPU)

		loadsegment(gs, 0);

}
@@ -962,6 +941,11 @@ static const struct pv_cpu_ops xen_cpu_ops __initdata = { 


	.set_iopl_mask = xen_set_iopl_mask,

	.io_delay = xen_io_delay,



	.lazy_mode = {

		.enter = paravirt_enter_lazy_cpu,

		.leave = xen_leave_lazy,

	},

};



static const struct pv_irq_ops xen_irq_ops __initdata = {
@@ -1037,10 +1021,11 @@ static const struct pv_mmu_ops xen_mmu_ops __initdata = { 
	.activate_mm = xen_activate_mm,

	.dup_mmap = xen_dup_mmap,

	.exit_mmap = xen_exit_mmap,

};



static const struct pv_misc_ops xen_misc_ops __initdata = {

	.set_lazy_mode = xen_set_lazy_mode,

	.lazy_mode = {

		.enter = paravirt_enter_lazy_mmu,

		.leave = xen_leave_lazy,

	},

};



#ifdef CONFIG_SMP
@@ -1114,7 +1099,6 @@ asmlinkage void __init xen_start_kernel(void) 
	pv_irq_ops = xen_irq_ops;

	pv_apic_ops = xen_apic_ops;

	pv_mmu_ops = xen_mmu_ops;

	pv_misc_ops = xen_misc_ops;



	machine_ops = xen_machine_ops;

arch/x86/xen/mmu.c

+1 −1
Original line number Diff line number Diff line
@@ -155,7 +155,7 @@ void xen_set_pte_at(struct mm_struct *mm, unsigned long addr, 
		    pte_t *ptep, pte_t pteval)

{

	if (mm == current->mm || mm == &init_mm) {

		if (xen_get_lazy_mode() == PARAVIRT_LAZY_MMU) {

		if (paravirt_get_lazy_mode() == PARAVIRT_LAZY_MMU) {

			struct multicall_space mcs;

			mcs = xen_mc_entry(0);

arch/x86/xen/multicalls.h

+1 −1
Original line number Diff line number Diff line
@@ -35,7 +35,7 @@ void xen_mc_flush(void); 
/* Issue a multicall if we're not in a lazy mode */

static inline void xen_mc_issue(unsigned mode)

{

	if ((xen_get_lazy_mode() & mode) == 0)

	if ((paravirt_get_lazy_mode() & mode) == 0)

		xen_mc_flush();



	/* restore flags saved in xen_mc_batch */

CRA Git | Maintained and supported by SUSTech CRA and CCSE