2006-12-07 01:14:07 +00:00
|
|
|
#ifndef __ASM_PARAVIRT_H
|
|
|
|
#define __ASM_PARAVIRT_H
|
|
|
|
/* Various instructions on x86 need to be replaced for
|
|
|
|
* para-virtualization: those hooks are defined here. */
|
[PATCH] i386: PARAVIRT: Hooks to set up initial pagetable
This patch introduces paravirt_ops hooks to control how the kernel's
initial pagetable is set up.
In the case of a native boot, the very early bootstrap code creates a
simple non-PAE pagetable to map the kernel and physical memory. When
the VM subsystem is initialized, it creates a proper pagetable which
respects the PAE mode, large pages, etc.
When booting under a hypervisor, there are many possibilities for what
paging environment the hypervisor establishes for the guest kernel, so
the constructon of the kernel's pagetable depends on the hypervisor.
In the case of Xen, the hypervisor boots the kernel with a fully
constructed pagetable, which is already using PAE if necessary. Also,
Xen requires particular care when constructing pagetables to make sure
all pagetables are always mapped read-only.
In order to make this easier, kernel's initial pagetable construction
has been changed to only allocate and initialize a pagetable page if
there's no page already present in the pagetable. This allows the Xen
paravirt backend to make a copy of the hypervisor-provided pagetable,
allowing the kernel to establish any more mappings it needs while
keeping the existing ones.
A slightly subtle point which is worth highlighting here is that Xen
requires all kernel mappings to share the same pte_t pages between all
pagetables, so that updating a kernel page's mapping in one pagetable
is reflected in all other pagetables. This makes it possible to
allocate a page and attach it to a pagetable without having to
explicitly enumerate that page's mapping in all pagetables.
And:
+From: "Eric W. Biederman" <ebiederm@xmission.com>
If we don't set the leaf page table entries it is quite possible that
will inherit and incorrect page table entry from the initial boot
page table setup in head.S. So we need to redo the effort here,
so we pick up PSE, PGE and the like.
Hypervisors like Xen require that their page tables be read-only,
which is slightly incompatible with our low identity mappings, however
I discussed this with Jeremy he has modified the Xen early set_pte
function to avoid problems in this area.
Signed-off-by: Eric W. Biederman <ebiederm@xmission.com>
Signed-off-by: Jeremy Fitzhardinge <jeremy@xensource.com>
Signed-off-by: Andi Kleen <ak@suse.de>
Acked-by: William Irwin <bill.irwin@oracle.com>
Cc: Ingo Molnar <mingo@elte.hu>
2007-05-02 17:27:13 +00:00
|
|
|
|
|
|
|
#ifdef CONFIG_PARAVIRT
|
2006-12-07 01:14:08 +00:00
|
|
|
#include <asm/page.h>
|
2008-01-30 12:32:06 +00:00
|
|
|
#include <asm/asm.h>
|
2006-12-07 01:14:07 +00:00
|
|
|
|
2006-12-07 01:14:08 +00:00
|
|
|
/* Bitmask of what can be clobbered: usually at least eax. */
|
2008-01-30 12:32:09 +00:00
|
|
|
#define CLBR_NONE 0
|
|
|
|
#define CLBR_EAX (1 << 0)
|
|
|
|
#define CLBR_ECX (1 << 1)
|
|
|
|
#define CLBR_EDX (1 << 2)
|
|
|
|
|
|
|
|
#ifdef CONFIG_X86_64
|
|
|
|
#define CLBR_RSI (1 << 3)
|
|
|
|
#define CLBR_RDI (1 << 4)
|
|
|
|
#define CLBR_R8 (1 << 5)
|
|
|
|
#define CLBR_R9 (1 << 6)
|
|
|
|
#define CLBR_R10 (1 << 7)
|
|
|
|
#define CLBR_R11 (1 << 8)
|
|
|
|
#define CLBR_ANY ((1 << 9) - 1)
|
|
|
|
#include <asm/desc_defs.h>
|
|
|
|
#else
|
|
|
|
/* CLBR_ANY should match all regs platform has. For i386, that's just it */
|
|
|
|
#define CLBR_ANY ((1 << 3) - 1)
|
|
|
|
#endif /* X86_64 */
|
2006-12-07 01:14:08 +00:00
|
|
|
|
2006-12-07 01:14:07 +00:00
|
|
|
#ifndef __ASSEMBLY__
|
2007-05-02 17:27:13 +00:00
|
|
|
#include <linux/types.h>
|
2007-05-02 17:27:15 +00:00
|
|
|
#include <linux/cpumask.h>
|
2007-05-02 17:27:15 +00:00
|
|
|
#include <asm/kmap_types.h>
|
2008-01-30 12:31:12 +00:00
|
|
|
#include <asm/desc_defs.h>
|
2007-05-02 17:27:13 +00:00
|
|
|
|
2007-05-02 17:27:15 +00:00
|
|
|
struct page;
|
2006-12-07 01:14:07 +00:00
|
|
|
struct thread_struct;
|
2008-01-30 12:31:12 +00:00
|
|
|
struct desc_ptr;
|
2006-12-07 01:14:07 +00:00
|
|
|
struct tss_struct;
|
2006-12-07 01:14:08 +00:00
|
|
|
struct mm_struct;
|
2007-05-02 17:27:10 +00:00
|
|
|
struct desc_struct;
|
2007-05-02 17:27:14 +00:00
|
|
|
|
2007-10-16 18:51:29 +00:00
|
|
|
/* general info */
|
|
|
|
struct pv_info {
|
2006-12-07 01:14:07 +00:00
|
|
|
unsigned int kernel_rpl;
|
[PATCH] i386: PARAVIRT: Allow paravirt backend to choose kernel PMD sharing
Normally when running in PAE mode, the 4th PMD maps the kernel address space,
which can be shared among all processes (since they all need the same kernel
mappings).
Xen, however, does not allow guests to have the kernel pmd shared between page
tables, so parameterize pgtable.c to allow both modes of operation.
There are several side-effects of this. One is that vmalloc will update the
kernel address space mappings, and those updates need to be propagated into
all processes if the kernel mappings are not intrinsically shared. In the
non-PAE case, this is done by maintaining a pgd_list of all processes; this
list is used when all process pagetables must be updated. pgd_list is
threaded via otherwise unused entries in the page structure for the pgd, which
means that the pgd must be page-sized for this to work.
Normally the PAE pgd is only 4x64 byte entries large, but Xen requires the PAE
pgd to page aligned anyway, so this patch forces the pgd to be page
aligned+sized when the kernel pmd is unshared, to accomodate both these
requirements.
Also, since there may be several distinct kernel pmds (if the user/kernel
split is below 3G), there's no point in allocating them from a slab cache;
they're just allocated with get_free_page and initialized appropriately. (Of
course the could be cached if there is just a single kernel pmd - which is the
default with a 3G user/kernel split - but it doesn't seem worthwhile to add
yet another case into this code).
[ Many thanks to wli for review comments. ]
Signed-off-by: Jeremy Fitzhardinge <jeremy@xensource.com>
Signed-off-by: William Lee Irwin III <wli@holomorphy.com>
Signed-off-by: Andi Kleen <ak@suse.de>
Cc: Zachary Amsden <zach@vmware.com>
Cc: Christoph Lameter <clameter@sgi.com>
Acked-by: Ingo Molnar <mingo@elte.hu>
Signed-off-by: Andrew Morton <akpm@linux-foundation.org>
2007-05-02 17:27:13 +00:00
|
|
|
int shared_kernel_pmd;
|
2007-10-16 18:51:29 +00:00
|
|
|
int paravirt_enabled;
|
2006-12-07 01:14:07 +00:00
|
|
|
const char *name;
|
2007-10-16 18:51:29 +00:00
|
|
|
};
|
2006-12-07 01:14:07 +00:00
|
|
|
|
2007-10-16 18:51:29 +00:00
|
|
|
struct pv_init_ops {
|
2006-12-07 01:14:08 +00:00
|
|
|
/*
|
2007-10-16 18:51:29 +00:00
|
|
|
* Patch may replace one of the defined code sequences with
|
|
|
|
* arbitrary code, subject to the same register constraints.
|
|
|
|
* This generally means the code is not free to clobber any
|
|
|
|
* registers other than EAX. The patch function should return
|
|
|
|
* the number of bytes of code generated, as we nop pad the
|
|
|
|
* rest in generic code.
|
2006-12-07 01:14:08 +00:00
|
|
|
*/
|
2007-08-10 20:31:03 +00:00
|
|
|
unsigned (*patch)(u8 type, u16 clobber, void *insnbuf,
|
|
|
|
unsigned long addr, unsigned len);
|
2006-12-07 01:14:08 +00:00
|
|
|
|
2007-05-02 17:27:14 +00:00
|
|
|
/* Basic arch-specific setup */
|
2006-12-07 01:14:07 +00:00
|
|
|
void (*arch_setup)(void);
|
|
|
|
char *(*memory_setup)(void);
|
2007-07-18 01:37:03 +00:00
|
|
|
void (*post_allocator_init)(void);
|
|
|
|
|
2007-05-02 17:27:14 +00:00
|
|
|
/* Print a banner to identify the environment */
|
2006-12-07 01:14:07 +00:00
|
|
|
void (*banner)(void);
|
2007-10-16 18:51:29 +00:00
|
|
|
};
|
|
|
|
|
|
|
|
|
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: Jeremy 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>
2007-10-16 18:51:29 +00:00
|
|
|
struct pv_lazy_ops {
|
2007-10-16 18:51:29 +00:00
|
|
|
/* Set deferred update mode, used for batching operations. */
|
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: Jeremy 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>
2007-10-16 18:51:29 +00:00
|
|
|
void (*enter)(void);
|
|
|
|
void (*leave)(void);
|
2007-10-16 18:51:29 +00:00
|
|
|
};
|
|
|
|
|
|
|
|
struct pv_time_ops {
|
|
|
|
void (*time_init)(void);
|
2006-12-07 01:14:07 +00:00
|
|
|
|
2007-05-02 17:27:14 +00:00
|
|
|
/* Set and set time of day */
|
2006-12-07 01:14:07 +00:00
|
|
|
unsigned long (*get_wallclock)(void);
|
|
|
|
int (*set_wallclock)(unsigned long);
|
|
|
|
|
2007-10-16 18:51:29 +00:00
|
|
|
unsigned long long (*sched_clock)(void);
|
|
|
|
unsigned long (*get_cpu_khz)(void);
|
|
|
|
};
|
2006-12-07 01:14:07 +00:00
|
|
|
|
2007-10-16 18:51:29 +00:00
|
|
|
struct pv_cpu_ops {
|
2007-05-02 17:27:14 +00:00
|
|
|
/* hooks for various privileged instructions */
|
2007-02-13 12:26:25 +00:00
|
|
|
unsigned long (*get_debugreg)(int regno);
|
|
|
|
void (*set_debugreg)(int regno, unsigned long value);
|
2006-12-07 01:14:07 +00:00
|
|
|
|
2007-02-13 12:26:25 +00:00
|
|
|
void (*clts)(void);
|
2006-12-07 01:14:07 +00:00
|
|
|
|
2007-02-13 12:26:25 +00:00
|
|
|
unsigned long (*read_cr0)(void);
|
|
|
|
void (*write_cr0)(unsigned long);
|
2006-12-07 01:14:07 +00:00
|
|
|
|
2007-02-13 12:26:25 +00:00
|
|
|
unsigned long (*read_cr4_safe)(void);
|
|
|
|
unsigned long (*read_cr4)(void);
|
|
|
|
void (*write_cr4)(unsigned long);
|
2006-12-07 01:14:07 +00:00
|
|
|
|
2008-01-30 12:33:19 +00:00
|
|
|
#ifdef CONFIG_X86_64
|
|
|
|
unsigned long (*read_cr8)(void);
|
|
|
|
void (*write_cr8)(unsigned long);
|
|
|
|
#endif
|
|
|
|
|
2007-05-02 17:27:14 +00:00
|
|
|
/* Segment descriptor handling */
|
2007-02-13 12:26:25 +00:00
|
|
|
void (*load_tr_desc)(void);
|
2008-01-30 12:31:12 +00:00
|
|
|
void (*load_gdt)(const struct desc_ptr *);
|
|
|
|
void (*load_idt)(const struct desc_ptr *);
|
|
|
|
void (*store_gdt)(struct desc_ptr *);
|
|
|
|
void (*store_idt)(struct desc_ptr *);
|
2007-02-13 12:26:25 +00:00
|
|
|
void (*set_ldt)(const void *desc, unsigned entries);
|
|
|
|
unsigned long (*store_tr)(void);
|
|
|
|
void (*load_tls)(struct thread_struct *t, unsigned int cpu);
|
2008-01-30 12:31:13 +00:00
|
|
|
void (*write_ldt_entry)(struct desc_struct *ldt, int entrynum,
|
|
|
|
const void *desc);
|
2007-05-02 17:27:10 +00:00
|
|
|
void (*write_gdt_entry)(struct desc_struct *,
|
2008-01-30 12:31:13 +00:00
|
|
|
int entrynum, const void *desc, int size);
|
2008-01-30 12:31:12 +00:00
|
|
|
void (*write_idt_entry)(gate_desc *,
|
|
|
|
int entrynum, const gate_desc *gate);
|
2008-01-30 12:31:02 +00:00
|
|
|
void (*load_sp0)(struct tss_struct *tss, struct thread_struct *t);
|
2006-12-07 01:14:07 +00:00
|
|
|
|
2007-02-13 12:26:25 +00:00
|
|
|
void (*set_iopl_mask)(unsigned mask);
|
2007-10-16 18:51:29 +00:00
|
|
|
|
|
|
|
void (*wbinvd)(void);
|
2007-02-13 12:26:25 +00:00
|
|
|
void (*io_delay)(void);
|
2006-12-07 01:14:07 +00:00
|
|
|
|
2007-10-16 18:51:29 +00:00
|
|
|
/* cpuid emulation, mostly so that caps bits can be disabled */
|
|
|
|
void (*cpuid)(unsigned int *eax, unsigned int *ebx,
|
|
|
|
unsigned int *ecx, unsigned int *edx);
|
|
|
|
|
|
|
|
/* MSR, PMC and TSR operations.
|
|
|
|
err = 0/-EFAULT. wrmsr returns 0/-EFAULT. */
|
|
|
|
u64 (*read_msr)(unsigned int msr, int *err);
|
2008-01-30 12:31:07 +00:00
|
|
|
int (*write_msr)(unsigned int msr, unsigned low, unsigned high);
|
2007-10-16 18:51:29 +00:00
|
|
|
|
|
|
|
u64 (*read_tsc)(void);
|
2008-01-30 12:31:07 +00:00
|
|
|
u64 (*read_pmc)(int counter);
|
2008-01-30 12:32:05 +00:00
|
|
|
unsigned long long (*read_tscp)(unsigned int *aux);
|
2007-10-16 18:51:29 +00:00
|
|
|
|
2008-06-25 04:19:28 +00:00
|
|
|
/*
|
|
|
|
* Atomically enable interrupts and return to userspace. This
|
|
|
|
* is only ever used to return to 32-bit processes; in a
|
|
|
|
* 64-bit kernel, it's used for 32-on-64 compat processes, but
|
|
|
|
* never native 64-bit processes. (Jump, not call.)
|
|
|
|
*/
|
2008-06-25 04:19:26 +00:00
|
|
|
void (*irq_enable_sysexit)(void);
|
2008-06-25 04:19:28 +00:00
|
|
|
|
|
|
|
/*
|
|
|
|
* Switch to usermode gs and return to 64-bit usermode using
|
|
|
|
* sysret. Only used in 64-bit kernels to return to 64-bit
|
|
|
|
* processes. Usermode register state, including %rsp, must
|
|
|
|
* already be restored.
|
|
|
|
*/
|
|
|
|
void (*usergs_sysret64)(void);
|
|
|
|
|
|
|
|
/*
|
|
|
|
* Switch to usermode gs and return to 32-bit usermode using
|
|
|
|
* sysret. Used to return to 32-on-64 compat processes.
|
|
|
|
* Other usermode register state, including %esp, must already
|
|
|
|
* be restored.
|
|
|
|
*/
|
|
|
|
void (*usergs_sysret32)(void);
|
|
|
|
|
|
|
|
/* Normal iret. Jump to this with the standard iret stack
|
|
|
|
frame set up. */
|
2007-10-16 18:51:29 +00:00
|
|
|
void (*iret)(void);
|
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: Jeremy 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>
2007-10-16 18:51:29 +00:00
|
|
|
|
2008-01-30 12:32:08 +00:00
|
|
|
void (*swapgs)(void);
|
|
|
|
|
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: Jeremy 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>
2007-10-16 18:51:29 +00:00
|
|
|
struct pv_lazy_ops lazy_mode;
|
2007-10-16 18:51:29 +00:00
|
|
|
};
|
|
|
|
|
|
|
|
struct pv_irq_ops {
|
|
|
|
void (*init_IRQ)(void);
|
|
|
|
|
2007-05-02 17:27:14 +00:00
|
|
|
/*
|
2007-10-16 18:51:29 +00:00
|
|
|
* Get/set interrupt state. save_fl and restore_fl are only
|
|
|
|
* expected to use X86_EFLAGS_IF; all other bits
|
|
|
|
* returned from save_fl are undefined, and may be ignored by
|
|
|
|
* restore_fl.
|
2007-05-02 17:27:14 +00:00
|
|
|
*/
|
2007-10-16 18:51:29 +00:00
|
|
|
unsigned long (*save_fl)(void);
|
|
|
|
void (*restore_fl)(unsigned long);
|
|
|
|
void (*irq_disable)(void);
|
|
|
|
void (*irq_enable)(void);
|
|
|
|
void (*safe_halt)(void);
|
|
|
|
void (*halt)(void);
|
|
|
|
};
|
2007-05-02 17:27:14 +00:00
|
|
|
|
2007-10-16 18:51:29 +00:00
|
|
|
struct pv_apic_ops {
|
2006-12-07 01:14:08 +00:00
|
|
|
#ifdef CONFIG_X86_LOCAL_APIC
|
2007-05-02 17:27:14 +00:00
|
|
|
/*
|
|
|
|
* Direct APIC operations, principally for VMI. Ideally
|
|
|
|
* these shouldn't be in this interface.
|
|
|
|
*/
|
2008-01-30 12:30:15 +00:00
|
|
|
void (*apic_write)(unsigned long reg, u32 v);
|
|
|
|
void (*apic_write_atomic)(unsigned long reg, u32 v);
|
|
|
|
u32 (*apic_read)(unsigned long reg);
|
2007-02-13 12:26:21 +00:00
|
|
|
void (*setup_boot_clock)(void);
|
|
|
|
void (*setup_secondary_clock)(void);
|
2007-05-02 17:27:14 +00:00
|
|
|
|
|
|
|
void (*startup_ipi_hook)(int phys_apicid,
|
|
|
|
unsigned long start_eip,
|
|
|
|
unsigned long start_esp);
|
2006-12-07 01:14:08 +00:00
|
|
|
#endif
|
2007-10-16 18:51:29 +00:00
|
|
|
};
|
|
|
|
|
|
|
|
struct pv_mmu_ops {
|
|
|
|
/*
|
|
|
|
* Called before/after init_mm pagetable setup. setup_start
|
|
|
|
* may reset %cr3, and may pre-install parts of the pagetable;
|
|
|
|
* pagetable setup is expected to preserve any existing
|
|
|
|
* mapping.
|
|
|
|
*/
|
|
|
|
void (*pagetable_setup_start)(pgd_t *pgd_base);
|
|
|
|
void (*pagetable_setup_done)(pgd_t *pgd_base);
|
|
|
|
|
|
|
|
unsigned long (*read_cr2)(void);
|
|
|
|
void (*write_cr2)(unsigned long);
|
|
|
|
|
|
|
|
unsigned long (*read_cr3)(void);
|
|
|
|
void (*write_cr3)(unsigned long);
|
|
|
|
|
|
|
|
/*
|
|
|
|
* Hooks for intercepting the creation/use/destruction of an
|
|
|
|
* mm_struct.
|
|
|
|
*/
|
|
|
|
void (*activate_mm)(struct mm_struct *prev,
|
|
|
|
struct mm_struct *next);
|
|
|
|
void (*dup_mmap)(struct mm_struct *oldmm,
|
|
|
|
struct mm_struct *mm);
|
|
|
|
void (*exit_mmap)(struct mm_struct *mm);
|
|
|
|
|
2006-12-07 01:14:08 +00:00
|
|
|
|
2007-05-02 17:27:14 +00:00
|
|
|
/* TLB operations */
|
2007-02-13 12:26:25 +00:00
|
|
|
void (*flush_tlb_user)(void);
|
|
|
|
void (*flush_tlb_kernel)(void);
|
2007-05-02 17:27:14 +00:00
|
|
|
void (*flush_tlb_single)(unsigned long addr);
|
2007-05-02 17:27:15 +00:00
|
|
|
void (*flush_tlb_others)(const cpumask_t *cpus, struct mm_struct *mm,
|
|
|
|
unsigned long va);
|
2007-02-13 12:26:25 +00:00
|
|
|
|
2008-06-25 04:19:12 +00:00
|
|
|
/* Hooks for allocating and freeing a pagetable top-level */
|
|
|
|
int (*pgd_alloc)(struct mm_struct *mm);
|
|
|
|
void (*pgd_free)(struct mm_struct *mm, pgd_t *pgd);
|
|
|
|
|
|
|
|
/*
|
|
|
|
* Hooks for allocating/releasing pagetable pages when they're
|
|
|
|
* attached to a pagetable
|
|
|
|
*/
|
2008-03-17 23:37:01 +00:00
|
|
|
void (*alloc_pte)(struct mm_struct *mm, u32 pfn);
|
|
|
|
void (*alloc_pmd)(struct mm_struct *mm, u32 pfn);
|
|
|
|
void (*alloc_pmd_clone)(u32 pfn, u32 clonepfn, u32 start, u32 count);
|
2008-03-17 23:37:02 +00:00
|
|
|
void (*alloc_pud)(struct mm_struct *mm, u32 pfn);
|
2008-03-17 23:37:01 +00:00
|
|
|
void (*release_pte)(u32 pfn);
|
|
|
|
void (*release_pmd)(u32 pfn);
|
2008-03-17 23:37:02 +00:00
|
|
|
void (*release_pud)(u32 pfn);
|
2007-02-13 12:26:25 +00:00
|
|
|
|
2007-05-02 17:27:14 +00:00
|
|
|
/* Pagetable manipulation functions */
|
2007-02-13 12:26:25 +00:00
|
|
|
void (*set_pte)(pte_t *ptep, pte_t pteval);
|
2007-05-02 17:27:14 +00:00
|
|
|
void (*set_pte_at)(struct mm_struct *mm, unsigned long addr,
|
|
|
|
pte_t *ptep, pte_t pteval);
|
2007-02-13 12:26:25 +00:00
|
|
|
void (*set_pmd)(pmd_t *pmdp, pmd_t pmdval);
|
2008-03-23 08:03:00 +00:00
|
|
|
void (*pte_update)(struct mm_struct *mm, unsigned long addr,
|
|
|
|
pte_t *ptep);
|
2007-05-02 17:27:14 +00:00
|
|
|
void (*pte_update_defer)(struct mm_struct *mm,
|
|
|
|
unsigned long addr, pte_t *ptep);
|
2007-05-02 17:27:13 +00:00
|
|
|
|
2008-06-16 11:30:01 +00:00
|
|
|
pte_t (*ptep_modify_prot_start)(struct mm_struct *mm, unsigned long addr,
|
|
|
|
pte_t *ptep);
|
|
|
|
void (*ptep_modify_prot_commit)(struct mm_struct *mm, unsigned long addr,
|
|
|
|
pte_t *ptep, pte_t pte);
|
|
|
|
|
2008-01-30 12:33:15 +00:00
|
|
|
pteval_t (*pte_val)(pte_t);
|
2008-05-26 22:31:06 +00:00
|
|
|
pteval_t (*pte_flags)(pte_t);
|
2008-01-30 12:33:15 +00:00
|
|
|
pte_t (*make_pte)(pteval_t pte);
|
|
|
|
|
|
|
|
pgdval_t (*pgd_val)(pgd_t);
|
|
|
|
pgd_t (*make_pgd)(pgdval_t pgd);
|
|
|
|
|
|
|
|
#if PAGETABLE_LEVELS >= 3
|
2006-12-07 01:14:08 +00:00
|
|
|
#ifdef CONFIG_X86_PAE
|
2007-02-13 12:26:25 +00:00
|
|
|
void (*set_pte_atomic)(pte_t *ptep, pte_t pteval);
|
2007-10-16 18:51:29 +00:00
|
|
|
void (*set_pte_present)(struct mm_struct *mm, unsigned long addr,
|
|
|
|
pte_t *ptep, pte_t pte);
|
2008-03-23 08:03:00 +00:00
|
|
|
void (*pte_clear)(struct mm_struct *mm, unsigned long addr,
|
|
|
|
pte_t *ptep);
|
2007-02-13 12:26:25 +00:00
|
|
|
void (*pmd_clear)(pmd_t *pmdp);
|
2007-05-02 17:27:13 +00:00
|
|
|
|
2008-01-30 12:33:15 +00:00
|
|
|
#endif /* CONFIG_X86_PAE */
|
2007-05-02 17:27:13 +00:00
|
|
|
|
2008-01-30 12:33:15 +00:00
|
|
|
void (*set_pud)(pud_t *pudp, pud_t pudval);
|
2007-05-02 17:27:13 +00:00
|
|
|
|
2008-01-30 12:33:15 +00:00
|
|
|
pmdval_t (*pmd_val)(pmd_t);
|
|
|
|
pmd_t (*make_pmd)(pmdval_t pmd);
|
|
|
|
|
|
|
|
#if PAGETABLE_LEVELS == 4
|
|
|
|
pudval_t (*pud_val)(pud_t);
|
|
|
|
pud_t (*make_pud)(pudval_t pud);
|
2008-01-30 12:33:20 +00:00
|
|
|
|
|
|
|
void (*set_pgd)(pgd_t *pudp, pgd_t pgdval);
|
2008-01-30 12:33:15 +00:00
|
|
|
#endif /* PAGETABLE_LEVELS == 4 */
|
|
|
|
#endif /* PAGETABLE_LEVELS >= 3 */
|
2006-12-07 01:14:08 +00:00
|
|
|
|
2007-10-16 18:51:29 +00:00
|
|
|
#ifdef CONFIG_HIGHPTE
|
|
|
|
void *(*kmap_atomic_pte)(struct page *page, enum km_type type);
|
|
|
|
#endif
|
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: Jeremy 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>
2007-10-16 18:51:29 +00:00
|
|
|
|
|
|
|
struct pv_lazy_ops lazy_mode;
|
2008-06-17 18:42:01 +00:00
|
|
|
|
|
|
|
/* dom0 ops */
|
|
|
|
|
|
|
|
/* Sometimes the physical address is a pfn, and sometimes its
|
|
|
|
an mfn. We can tell which is which from the index. */
|
|
|
|
void (*set_fixmap)(unsigned /* enum fixed_addresses */ idx,
|
|
|
|
unsigned long phys, pgprot_t flags);
|
2007-10-16 18:51:29 +00:00
|
|
|
};
|
2007-02-13 12:26:21 +00:00
|
|
|
|
2007-10-16 18:51:29 +00:00
|
|
|
/* This contains all the paravirt structures: we get a convenient
|
|
|
|
* number for each function using the offset which we use to indicate
|
|
|
|
* what to patch. */
|
2008-03-23 08:03:00 +00:00
|
|
|
struct paravirt_patch_template {
|
2007-10-16 18:51:29 +00:00
|
|
|
struct pv_init_ops pv_init_ops;
|
|
|
|
struct pv_time_ops pv_time_ops;
|
|
|
|
struct pv_cpu_ops pv_cpu_ops;
|
|
|
|
struct pv_irq_ops pv_irq_ops;
|
|
|
|
struct pv_apic_ops pv_apic_ops;
|
|
|
|
struct pv_mmu_ops pv_mmu_ops;
|
2006-12-07 01:14:07 +00:00
|
|
|
};
|
|
|
|
|
2007-10-16 18:51:29 +00:00
|
|
|
extern struct pv_info pv_info;
|
|
|
|
extern struct pv_init_ops pv_init_ops;
|
|
|
|
extern struct pv_time_ops pv_time_ops;
|
|
|
|
extern struct pv_cpu_ops pv_cpu_ops;
|
|
|
|
extern struct pv_irq_ops pv_irq_ops;
|
|
|
|
extern struct pv_apic_ops pv_apic_ops;
|
|
|
|
extern struct pv_mmu_ops pv_mmu_ops;
|
2006-12-07 01:14:07 +00:00
|
|
|
|
2007-05-02 17:27:14 +00:00
|
|
|
#define PARAVIRT_PATCH(x) \
|
2007-10-16 18:51:29 +00:00
|
|
|
(offsetof(struct paravirt_patch_template, x) / sizeof(void *))
|
2007-05-02 17:27:14 +00:00
|
|
|
|
2007-10-16 18:51:29 +00:00
|
|
|
#define paravirt_type(op) \
|
|
|
|
[paravirt_typenum] "i" (PARAVIRT_PATCH(op)), \
|
|
|
|
[paravirt_opptr] "m" (op)
|
2007-05-02 17:27:14 +00:00
|
|
|
#define paravirt_clobber(clobber) \
|
|
|
|
[paravirt_clobber] "i" (clobber)
|
|
|
|
|
2007-05-02 17:27:14 +00:00
|
|
|
/*
|
|
|
|
* Generate some code, and mark it as patchable by the
|
|
|
|
* apply_paravirt() alternate instruction patcher.
|
|
|
|
*/
|
2007-05-02 17:27:14 +00:00
|
|
|
#define _paravirt_alt(insn_string, type, clobber) \
|
|
|
|
"771:\n\t" insn_string "\n" "772:\n" \
|
|
|
|
".pushsection .parainstructions,\"a\"\n" \
|
2008-01-30 12:32:06 +00:00
|
|
|
_ASM_ALIGN "\n" \
|
|
|
|
_ASM_PTR " 771b\n" \
|
2007-05-02 17:27:14 +00:00
|
|
|
" .byte " type "\n" \
|
|
|
|
" .byte 772b-771b\n" \
|
|
|
|
" .short " clobber "\n" \
|
|
|
|
".popsection\n"
|
|
|
|
|
2007-05-02 17:27:14 +00:00
|
|
|
/* Generate patchable code, with the default asm parameters. */
|
2007-05-02 17:27:14 +00:00
|
|
|
#define paravirt_alt(insn_string) \
|
2007-05-02 17:27:14 +00:00
|
|
|
_paravirt_alt(insn_string, "%c[paravirt_typenum]", "%c[paravirt_clobber]")
|
|
|
|
|
2008-01-30 12:32:10 +00:00
|
|
|
/* Simple instruction patching code. */
|
|
|
|
#define DEF_NATIVE(ops, name, code) \
|
|
|
|
extern const char start_##ops##_##name[], end_##ops##_##name[]; \
|
|
|
|
asm("start_" #ops "_" #name ": " code "; end_" #ops "_" #name ":")
|
|
|
|
|
2007-05-02 17:27:14 +00:00
|
|
|
unsigned paravirt_patch_nop(void);
|
|
|
|
unsigned paravirt_patch_ignore(unsigned len);
|
2007-08-10 20:31:03 +00:00
|
|
|
unsigned paravirt_patch_call(void *insnbuf,
|
|
|
|
const void *target, u16 tgt_clobbers,
|
|
|
|
unsigned long addr, u16 site_clobbers,
|
2007-05-02 17:27:14 +00:00
|
|
|
unsigned len);
|
2007-10-16 18:51:29 +00:00
|
|
|
unsigned paravirt_patch_jmp(void *insnbuf, const void *target,
|
2007-08-10 20:31:03 +00:00
|
|
|
unsigned long addr, unsigned len);
|
|
|
|
unsigned paravirt_patch_default(u8 type, u16 clobbers, void *insnbuf,
|
|
|
|
unsigned long addr, unsigned len);
|
2007-05-02 17:27:14 +00:00
|
|
|
|
2007-08-10 20:31:03 +00:00
|
|
|
unsigned paravirt_patch_insns(void *insnbuf, unsigned len,
|
2007-05-02 17:27:14 +00:00
|
|
|
const char *start, const char *end);
|
|
|
|
|
2008-01-30 12:32:10 +00:00
|
|
|
unsigned native_patch(u8 type, u16 clobbers, void *ibuf,
|
|
|
|
unsigned long addr, unsigned len);
|
|
|
|
|
2007-07-18 01:37:04 +00:00
|
|
|
int paravirt_disable_iospace(void);
|
2007-05-02 17:27:14 +00:00
|
|
|
|
2007-05-02 17:27:14 +00:00
|
|
|
/*
|
|
|
|
* This generates an indirect call based on the operation type number.
|
|
|
|
* The type number, computed in PARAVIRT_PATCH, is derived from the
|
2007-10-16 18:51:29 +00:00
|
|
|
* offset into the paravirt_patch_template structure, and can therefore be
|
|
|
|
* freely converted back into a structure offset.
|
2007-05-02 17:27:14 +00:00
|
|
|
*/
|
2007-10-16 18:51:29 +00:00
|
|
|
#define PARAVIRT_CALL "call *%[paravirt_opptr];"
|
2007-05-02 17:27:14 +00:00
|
|
|
|
|
|
|
/*
|
2007-10-16 18:51:29 +00:00
|
|
|
* These macros are intended to wrap calls through one of the paravirt
|
|
|
|
* ops structs, so that they can be later identified and patched at
|
2007-05-02 17:27:14 +00:00
|
|
|
* runtime.
|
|
|
|
*
|
|
|
|
* Normally, a call to a pv_op function is a simple indirect call:
|
2008-01-30 12:32:05 +00:00
|
|
|
* (pv_op_struct.operations)(args...).
|
2007-05-02 17:27:14 +00:00
|
|
|
*
|
|
|
|
* Unfortunately, this is a relatively slow operation for modern CPUs,
|
|
|
|
* because it cannot necessarily determine what the destination
|
|
|
|
* address is. In this case, the address is a runtime constant, so at
|
|
|
|
* the very least we can patch the call to e a simple direct call, or
|
|
|
|
* ideally, patch an inline implementation into the callsite. (Direct
|
|
|
|
* calls are essentially free, because the call and return addresses
|
|
|
|
* are completely predictable.)
|
|
|
|
*
|
2008-01-30 12:32:05 +00:00
|
|
|
* For i386, these macros rely on the standard gcc "regparm(3)" calling
|
2007-05-02 17:27:14 +00:00
|
|
|
* convention, in which the first three arguments are placed in %eax,
|
|
|
|
* %edx, %ecx (in that order), and the remaining arguments are placed
|
|
|
|
* on the stack. All caller-save registers (eax,edx,ecx) are expected
|
|
|
|
* to be modified (either clobbered or used for return values).
|
2008-01-30 12:32:05 +00:00
|
|
|
* X86_64, on the other hand, already specifies a register-based calling
|
|
|
|
* conventions, returning at %rax, with parameteres going on %rdi, %rsi,
|
|
|
|
* %rdx, and %rcx. Note that for this reason, x86_64 does not need any
|
|
|
|
* special handling for dealing with 4 arguments, unlike i386.
|
|
|
|
* However, x86_64 also have to clobber all caller saved registers, which
|
|
|
|
* unfortunately, are quite a bit (r8 - r11)
|
2007-05-02 17:27:14 +00:00
|
|
|
*
|
|
|
|
* The call instruction itself is marked by placing its start address
|
|
|
|
* and size into the .parainstructions section, so that
|
|
|
|
* apply_paravirt() in arch/i386/kernel/alternative.c can do the
|
2007-10-16 18:51:29 +00:00
|
|
|
* appropriate patching under the control of the backend pv_init_ops
|
2007-05-02 17:27:14 +00:00
|
|
|
* implementation.
|
|
|
|
*
|
|
|
|
* Unfortunately there's no way to get gcc to generate the args setup
|
|
|
|
* for the call, and then allow the call itself to be generated by an
|
|
|
|
* inline asm. Because of this, we must do the complete arg setup and
|
|
|
|
* return value handling from within these macros. This is fairly
|
|
|
|
* cumbersome.
|
|
|
|
*
|
|
|
|
* There are 5 sets of PVOP_* macros for dealing with 0-4 arguments.
|
|
|
|
* It could be extended to more arguments, but there would be little
|
|
|
|
* to be gained from that. For each number of arguments, there are
|
|
|
|
* the two VCALL and CALL variants for void and non-void functions.
|
|
|
|
*
|
|
|
|
* When there is a return value, the invoker of the macro must specify
|
|
|
|
* the return type. The macro then uses sizeof() on that type to
|
|
|
|
* determine whether its a 32 or 64 bit value, and places the return
|
|
|
|
* in the right register(s) (just %eax for 32-bit, and %edx:%eax for
|
2008-01-30 12:32:05 +00:00
|
|
|
* 64-bit). For x86_64 machines, it just returns at %rax regardless of
|
|
|
|
* the return value size.
|
2007-05-02 17:27:14 +00:00
|
|
|
*
|
|
|
|
* 64-bit arguments are passed as a pair of adjacent 32-bit arguments
|
2008-01-30 12:32:05 +00:00
|
|
|
* i386 also passes 64-bit arguments as a pair of adjacent 32-bit arguments
|
|
|
|
* in low,high order
|
2007-05-02 17:27:14 +00:00
|
|
|
*
|
|
|
|
* Small structures are passed and returned in registers. The macro
|
|
|
|
* calling convention can't directly deal with this, so the wrapper
|
|
|
|
* functions must do this.
|
|
|
|
*
|
|
|
|
* These PVOP_* macros are only defined within this header. This
|
|
|
|
* means that all uses must be wrapped in inline functions. This also
|
|
|
|
* makes sure the incoming and outgoing types are always correct.
|
|
|
|
*/
|
2008-01-30 12:32:05 +00:00
|
|
|
#ifdef CONFIG_X86_32
|
|
|
|
#define PVOP_VCALL_ARGS unsigned long __eax, __edx, __ecx
|
|
|
|
#define PVOP_CALL_ARGS PVOP_VCALL_ARGS
|
|
|
|
#define PVOP_VCALL_CLOBBERS "=a" (__eax), "=d" (__edx), \
|
|
|
|
"=c" (__ecx)
|
|
|
|
#define PVOP_CALL_CLOBBERS PVOP_VCALL_CLOBBERS
|
|
|
|
#define EXTRA_CLOBBERS
|
|
|
|
#define VEXTRA_CLOBBERS
|
|
|
|
#else
|
|
|
|
#define PVOP_VCALL_ARGS unsigned long __edi, __esi, __edx, __ecx
|
|
|
|
#define PVOP_CALL_ARGS PVOP_VCALL_ARGS, __eax
|
|
|
|
#define PVOP_VCALL_CLOBBERS "=D" (__edi), \
|
|
|
|
"=S" (__esi), "=d" (__edx), \
|
|
|
|
"=c" (__ecx)
|
|
|
|
|
|
|
|
#define PVOP_CALL_CLOBBERS PVOP_VCALL_CLOBBERS, "=a" (__eax)
|
|
|
|
|
|
|
|
#define EXTRA_CLOBBERS , "r8", "r9", "r10", "r11"
|
|
|
|
#define VEXTRA_CLOBBERS , "rax", "r8", "r9", "r10", "r11"
|
|
|
|
#endif
|
|
|
|
|
2008-06-25 04:19:14 +00:00
|
|
|
#ifdef CONFIG_PARAVIRT_DEBUG
|
|
|
|
#define PVOP_TEST_NULL(op) BUG_ON(op == NULL)
|
|
|
|
#else
|
|
|
|
#define PVOP_TEST_NULL(op) ((void)op)
|
|
|
|
#endif
|
|
|
|
|
2007-05-02 17:27:15 +00:00
|
|
|
#define __PVOP_CALL(rettype, op, pre, post, ...) \
|
2007-05-02 17:27:14 +00:00
|
|
|
({ \
|
2007-05-02 17:27:15 +00:00
|
|
|
rettype __ret; \
|
2008-01-30 12:32:05 +00:00
|
|
|
PVOP_CALL_ARGS; \
|
2008-06-25 04:19:14 +00:00
|
|
|
PVOP_TEST_NULL(op); \
|
2008-01-30 12:32:05 +00:00
|
|
|
/* This is 32-bit specific, but is okay in 64-bit */ \
|
|
|
|
/* since this condition will never hold */ \
|
2007-05-02 17:27:15 +00:00
|
|
|
if (sizeof(rettype) > sizeof(unsigned long)) { \
|
|
|
|
asm volatile(pre \
|
|
|
|
paravirt_alt(PARAVIRT_CALL) \
|
|
|
|
post \
|
2008-01-30 12:32:05 +00:00
|
|
|
: PVOP_CALL_CLOBBERS \
|
2007-05-02 17:27:15 +00:00
|
|
|
: paravirt_type(op), \
|
|
|
|
paravirt_clobber(CLBR_ANY), \
|
|
|
|
##__VA_ARGS__ \
|
2008-01-30 12:32:05 +00:00
|
|
|
: "memory", "cc" EXTRA_CLOBBERS); \
|
2007-05-02 17:27:15 +00:00
|
|
|
__ret = (rettype)((((u64)__edx) << 32) | __eax); \
|
2007-05-02 17:27:14 +00:00
|
|
|
} else { \
|
2007-05-02 17:27:15 +00:00
|
|
|
asm volatile(pre \
|
2007-05-02 17:27:14 +00:00
|
|
|
paravirt_alt(PARAVIRT_CALL) \
|
2007-05-02 17:27:15 +00:00
|
|
|
post \
|
2008-01-30 12:32:05 +00:00
|
|
|
: PVOP_CALL_CLOBBERS \
|
2007-05-02 17:27:15 +00:00
|
|
|
: paravirt_type(op), \
|
|
|
|
paravirt_clobber(CLBR_ANY), \
|
|
|
|
##__VA_ARGS__ \
|
2008-01-30 12:32:05 +00:00
|
|
|
: "memory", "cc" EXTRA_CLOBBERS); \
|
2007-05-02 17:27:15 +00:00
|
|
|
__ret = (rettype)__eax; \
|
2007-05-02 17:27:14 +00:00
|
|
|
} \
|
|
|
|
__ret; \
|
|
|
|
})
|
2007-05-02 17:27:15 +00:00
|
|
|
#define __PVOP_VCALL(op, pre, post, ...) \
|
2007-05-02 17:27:14 +00:00
|
|
|
({ \
|
2008-01-30 12:32:05 +00:00
|
|
|
PVOP_VCALL_ARGS; \
|
2008-06-25 04:19:14 +00:00
|
|
|
PVOP_TEST_NULL(op); \
|
2007-05-02 17:27:15 +00:00
|
|
|
asm volatile(pre \
|
2007-05-02 17:27:14 +00:00
|
|
|
paravirt_alt(PARAVIRT_CALL) \
|
2007-05-02 17:27:15 +00:00
|
|
|
post \
|
2008-01-30 12:32:05 +00:00
|
|
|
: PVOP_VCALL_CLOBBERS \
|
2007-05-02 17:27:15 +00:00
|
|
|
: paravirt_type(op), \
|
|
|
|
paravirt_clobber(CLBR_ANY), \
|
|
|
|
##__VA_ARGS__ \
|
2008-01-30 12:32:05 +00:00
|
|
|
: "memory", "cc" VEXTRA_CLOBBERS); \
|
2007-05-02 17:27:14 +00:00
|
|
|
})
|
|
|
|
|
2007-05-02 17:27:15 +00:00
|
|
|
#define PVOP_CALL0(rettype, op) \
|
|
|
|
__PVOP_CALL(rettype, op, "", "")
|
|
|
|
#define PVOP_VCALL0(op) \
|
|
|
|
__PVOP_VCALL(op, "", "")
|
|
|
|
|
|
|
|
#define PVOP_CALL1(rettype, op, arg1) \
|
2008-01-30 12:32:05 +00:00
|
|
|
__PVOP_CALL(rettype, op, "", "", "0" ((unsigned long)(arg1)))
|
2007-05-02 17:27:15 +00:00
|
|
|
#define PVOP_VCALL1(op, arg1) \
|
2008-01-30 12:32:05 +00:00
|
|
|
__PVOP_VCALL(op, "", "", "0" ((unsigned long)(arg1)))
|
2007-05-02 17:27:15 +00:00
|
|
|
|
|
|
|
#define PVOP_CALL2(rettype, op, arg1, arg2) \
|
2008-01-30 12:32:05 +00:00
|
|
|
__PVOP_CALL(rettype, op, "", "", "0" ((unsigned long)(arg1)), \
|
|
|
|
"1" ((unsigned long)(arg2)))
|
2007-05-02 17:27:15 +00:00
|
|
|
#define PVOP_VCALL2(op, arg1, arg2) \
|
2008-01-30 12:32:05 +00:00
|
|
|
__PVOP_VCALL(op, "", "", "0" ((unsigned long)(arg1)), \
|
|
|
|
"1" ((unsigned long)(arg2)))
|
2007-05-02 17:27:15 +00:00
|
|
|
|
|
|
|
#define PVOP_CALL3(rettype, op, arg1, arg2, arg3) \
|
2008-01-30 12:32:05 +00:00
|
|
|
__PVOP_CALL(rettype, op, "", "", "0" ((unsigned long)(arg1)), \
|
|
|
|
"1"((unsigned long)(arg2)), "2"((unsigned long)(arg3)))
|
2007-05-02 17:27:15 +00:00
|
|
|
#define PVOP_VCALL3(op, arg1, arg2, arg3) \
|
2008-01-30 12:32:05 +00:00
|
|
|
__PVOP_VCALL(op, "", "", "0" ((unsigned long)(arg1)), \
|
|
|
|
"1"((unsigned long)(arg2)), "2"((unsigned long)(arg3)))
|
2007-05-02 17:27:15 +00:00
|
|
|
|
2008-01-30 12:32:05 +00:00
|
|
|
/* This is the only difference in x86_64. We can make it much simpler */
|
|
|
|
#ifdef CONFIG_X86_32
|
2007-05-02 17:27:15 +00:00
|
|
|
#define PVOP_CALL4(rettype, op, arg1, arg2, arg3, arg4) \
|
|
|
|
__PVOP_CALL(rettype, op, \
|
|
|
|
"push %[_arg4];", "lea 4(%%esp),%%esp;", \
|
|
|
|
"0" ((u32)(arg1)), "1" ((u32)(arg2)), \
|
|
|
|
"2" ((u32)(arg3)), [_arg4] "mr" ((u32)(arg4)))
|
|
|
|
#define PVOP_VCALL4(op, arg1, arg2, arg3, arg4) \
|
|
|
|
__PVOP_VCALL(op, \
|
|
|
|
"push %[_arg4];", "lea 4(%%esp),%%esp;", \
|
|
|
|
"0" ((u32)(arg1)), "1" ((u32)(arg2)), \
|
|
|
|
"2" ((u32)(arg3)), [_arg4] "mr" ((u32)(arg4)))
|
2008-01-30 12:32:05 +00:00
|
|
|
#else
|
|
|
|
#define PVOP_CALL4(rettype, op, arg1, arg2, arg3, arg4) \
|
|
|
|
__PVOP_CALL(rettype, op, "", "", "0" ((unsigned long)(arg1)), \
|
|
|
|
"1"((unsigned long)(arg2)), "2"((unsigned long)(arg3)), \
|
|
|
|
"3"((unsigned long)(arg4)))
|
|
|
|
#define PVOP_VCALL4(op, arg1, arg2, arg3, arg4) \
|
|
|
|
__PVOP_VCALL(op, "", "", "0" ((unsigned long)(arg1)), \
|
|
|
|
"1"((unsigned long)(arg2)), "2"((unsigned long)(arg3)), \
|
|
|
|
"3"((unsigned long)(arg4)))
|
|
|
|
#endif
|
2007-05-02 17:27:15 +00:00
|
|
|
|
2007-05-02 17:27:14 +00:00
|
|
|
static inline int paravirt_enabled(void)
|
|
|
|
{
|
2007-10-16 18:51:29 +00:00
|
|
|
return pv_info.paravirt_enabled;
|
2007-05-02 17:27:14 +00:00
|
|
|
}
|
2006-12-07 01:14:07 +00:00
|
|
|
|
2008-01-30 12:31:02 +00:00
|
|
|
static inline void load_sp0(struct tss_struct *tss,
|
2006-12-07 01:14:07 +00:00
|
|
|
struct thread_struct *thread)
|
|
|
|
{
|
2008-01-30 12:31:02 +00:00
|
|
|
PVOP_VCALL2(pv_cpu_ops.load_sp0, tss, thread);
|
2006-12-07 01:14:07 +00:00
|
|
|
}
|
|
|
|
|
2007-10-16 18:51:29 +00:00
|
|
|
#define ARCH_SETUP pv_init_ops.arch_setup();
|
2006-12-07 01:14:07 +00:00
|
|
|
static inline unsigned long get_wallclock(void)
|
|
|
|
{
|
2007-10-16 18:51:29 +00:00
|
|
|
return PVOP_CALL0(unsigned long, pv_time_ops.get_wallclock);
|
2006-12-07 01:14:07 +00:00
|
|
|
}
|
|
|
|
|
|
|
|
static inline int set_wallclock(unsigned long nowtime)
|
|
|
|
{
|
2007-10-16 18:51:29 +00:00
|
|
|
return PVOP_CALL1(int, pv_time_ops.set_wallclock, nowtime);
|
2006-12-07 01:14:07 +00:00
|
|
|
}
|
|
|
|
|
2007-03-05 08:30:39 +00:00
|
|
|
static inline void (*choose_time_init(void))(void)
|
2006-12-07 01:14:07 +00:00
|
|
|
{
|
2007-10-16 18:51:29 +00:00
|
|
|
return pv_time_ops.time_init;
|
2006-12-07 01:14:07 +00:00
|
|
|
}
|
|
|
|
|
|
|
|
/* The paravirtualized CPUID instruction. */
|
|
|
|
static inline void __cpuid(unsigned int *eax, unsigned int *ebx,
|
|
|
|
unsigned int *ecx, unsigned int *edx)
|
|
|
|
{
|
2007-10-16 18:51:29 +00:00
|
|
|
PVOP_VCALL4(pv_cpu_ops.cpuid, eax, ebx, ecx, edx);
|
2006-12-07 01:14:07 +00:00
|
|
|
}
|
|
|
|
|
|
|
|
/*
|
|
|
|
* These special macros can be used to get or set a debugging register
|
|
|
|
*/
|
2007-05-02 17:27:14 +00:00
|
|
|
static inline unsigned long paravirt_get_debugreg(int reg)
|
|
|
|
{
|
2007-10-16 18:51:29 +00:00
|
|
|
return PVOP_CALL1(unsigned long, pv_cpu_ops.get_debugreg, reg);
|
2007-05-02 17:27:14 +00:00
|
|
|
}
|
|
|
|
#define get_debugreg(var, reg) var = paravirt_get_debugreg(reg)
|
|
|
|
static inline void set_debugreg(unsigned long val, int reg)
|
|
|
|
{
|
2007-10-16 18:51:29 +00:00
|
|
|
PVOP_VCALL2(pv_cpu_ops.set_debugreg, reg, val);
|
2007-05-02 17:27:14 +00:00
|
|
|
}
|
2006-12-07 01:14:07 +00:00
|
|
|
|
2007-05-02 17:27:14 +00:00
|
|
|
static inline void clts(void)
|
|
|
|
{
|
2007-10-16 18:51:29 +00:00
|
|
|
PVOP_VCALL0(pv_cpu_ops.clts);
|
2007-05-02 17:27:14 +00:00
|
|
|
}
|
2006-12-07 01:14:07 +00:00
|
|
|
|
2007-05-02 17:27:14 +00:00
|
|
|
static inline unsigned long read_cr0(void)
|
|
|
|
{
|
2007-10-16 18:51:29 +00:00
|
|
|
return PVOP_CALL0(unsigned long, pv_cpu_ops.read_cr0);
|
2007-05-02 17:27:14 +00:00
|
|
|
}
|
2006-12-07 01:14:07 +00:00
|
|
|
|
2007-05-02 17:27:14 +00:00
|
|
|
static inline void write_cr0(unsigned long x)
|
|
|
|
{
|
2007-10-16 18:51:29 +00:00
|
|
|
PVOP_VCALL1(pv_cpu_ops.write_cr0, x);
|
2007-05-02 17:27:14 +00:00
|
|
|
}
|
|
|
|
|
|
|
|
static inline unsigned long read_cr2(void)
|
|
|
|
{
|
2007-10-16 18:51:29 +00:00
|
|
|
return PVOP_CALL0(unsigned long, pv_mmu_ops.read_cr2);
|
2007-05-02 17:27:14 +00:00
|
|
|
}
|
|
|
|
|
|
|
|
static inline void write_cr2(unsigned long x)
|
|
|
|
{
|
2007-10-16 18:51:29 +00:00
|
|
|
PVOP_VCALL1(pv_mmu_ops.write_cr2, x);
|
2007-05-02 17:27:14 +00:00
|
|
|
}
|
|
|
|
|
|
|
|
static inline unsigned long read_cr3(void)
|
|
|
|
{
|
2007-10-16 18:51:29 +00:00
|
|
|
return PVOP_CALL0(unsigned long, pv_mmu_ops.read_cr3);
|
2007-05-02 17:27:14 +00:00
|
|
|
}
|
2006-12-07 01:14:07 +00:00
|
|
|
|
2007-05-02 17:27:14 +00:00
|
|
|
static inline void write_cr3(unsigned long x)
|
|
|
|
{
|
2007-10-16 18:51:29 +00:00
|
|
|
PVOP_VCALL1(pv_mmu_ops.write_cr3, x);
|
2007-05-02 17:27:14 +00:00
|
|
|
}
|
2006-12-07 01:14:07 +00:00
|
|
|
|
2007-05-02 17:27:14 +00:00
|
|
|
static inline unsigned long read_cr4(void)
|
|
|
|
{
|
2007-10-16 18:51:29 +00:00
|
|
|
return PVOP_CALL0(unsigned long, pv_cpu_ops.read_cr4);
|
2007-05-02 17:27:14 +00:00
|
|
|
}
|
|
|
|
static inline unsigned long read_cr4_safe(void)
|
|
|
|
{
|
2007-10-16 18:51:29 +00:00
|
|
|
return PVOP_CALL0(unsigned long, pv_cpu_ops.read_cr4_safe);
|
2007-05-02 17:27:14 +00:00
|
|
|
}
|
2006-12-07 01:14:07 +00:00
|
|
|
|
2007-05-02 17:27:14 +00:00
|
|
|
static inline void write_cr4(unsigned long x)
|
|
|
|
{
|
2007-10-16 18:51:29 +00:00
|
|
|
PVOP_VCALL1(pv_cpu_ops.write_cr4, x);
|
2007-05-02 17:27:14 +00:00
|
|
|
}
|
2007-05-02 17:27:13 +00:00
|
|
|
|
2008-01-30 12:33:19 +00:00
|
|
|
#ifdef CONFIG_X86_64
|
2008-01-30 12:33:19 +00:00
|
|
|
static inline unsigned long read_cr8(void)
|
|
|
|
{
|
|
|
|
return PVOP_CALL0(unsigned long, pv_cpu_ops.read_cr8);
|
|
|
|
}
|
|
|
|
|
|
|
|
static inline void write_cr8(unsigned long x)
|
|
|
|
{
|
|
|
|
PVOP_VCALL1(pv_cpu_ops.write_cr8, x);
|
|
|
|
}
|
2008-01-30 12:33:19 +00:00
|
|
|
#endif
|
2008-01-30 12:33:19 +00:00
|
|
|
|
2006-12-07 01:14:07 +00:00
|
|
|
static inline void raw_safe_halt(void)
|
|
|
|
{
|
2007-10-16 18:51:29 +00:00
|
|
|
PVOP_VCALL0(pv_irq_ops.safe_halt);
|
2006-12-07 01:14:07 +00:00
|
|
|
}
|
|
|
|
|
|
|
|
static inline void halt(void)
|
|
|
|
{
|
2007-10-16 18:51:29 +00:00
|
|
|
PVOP_VCALL0(pv_irq_ops.safe_halt);
|
2007-05-02 17:27:14 +00:00
|
|
|
}
|
|
|
|
|
|
|
|
static inline void wbinvd(void)
|
|
|
|
{
|
2007-10-16 18:51:29 +00:00
|
|
|
PVOP_VCALL0(pv_cpu_ops.wbinvd);
|
2006-12-07 01:14:07 +00:00
|
|
|
}
|
|
|
|
|
2007-10-16 18:51:29 +00:00
|
|
|
#define get_kernel_rpl() (pv_info.kernel_rpl)
|
2006-12-07 01:14:07 +00:00
|
|
|
|
2007-05-02 17:27:14 +00:00
|
|
|
static inline u64 paravirt_read_msr(unsigned msr, int *err)
|
|
|
|
{
|
2007-10-16 18:51:29 +00:00
|
|
|
return PVOP_CALL2(u64, pv_cpu_ops.read_msr, msr, err);
|
2007-05-02 17:27:14 +00:00
|
|
|
}
|
|
|
|
static inline int paravirt_write_msr(unsigned msr, unsigned low, unsigned high)
|
|
|
|
{
|
2007-10-16 18:51:29 +00:00
|
|
|
return PVOP_CALL3(int, pv_cpu_ops.write_msr, msr, low, high);
|
2007-05-02 17:27:14 +00:00
|
|
|
}
|
|
|
|
|
2007-05-02 17:27:10 +00:00
|
|
|
/* These should all do BUG_ON(_err), but our headers are too tangled. */
|
2008-03-23 08:03:00 +00:00
|
|
|
#define rdmsr(msr, val1, val2) \
|
|
|
|
do { \
|
2007-05-02 17:27:14 +00:00
|
|
|
int _err; \
|
|
|
|
u64 _l = paravirt_read_msr(msr, &_err); \
|
|
|
|
val1 = (u32)_l; \
|
|
|
|
val2 = _l >> 32; \
|
2008-03-23 08:03:00 +00:00
|
|
|
} while (0)
|
2006-12-07 01:14:07 +00:00
|
|
|
|
2008-03-23 08:03:00 +00:00
|
|
|
#define wrmsr(msr, val1, val2) \
|
|
|
|
do { \
|
2007-05-02 17:27:14 +00:00
|
|
|
paravirt_write_msr(msr, val1, val2); \
|
2008-03-23 08:03:00 +00:00
|
|
|
} while (0)
|
2006-12-07 01:14:07 +00:00
|
|
|
|
2008-03-23 08:03:00 +00:00
|
|
|
#define rdmsrl(msr, val) \
|
|
|
|
do { \
|
2007-05-02 17:27:14 +00:00
|
|
|
int _err; \
|
|
|
|
val = paravirt_read_msr(msr, &_err); \
|
2008-03-23 08:03:00 +00:00
|
|
|
} while (0)
|
2006-12-07 01:14:07 +00:00
|
|
|
|
2008-03-23 08:03:00 +00:00
|
|
|
#define wrmsrl(msr, val) wrmsr(msr, (u32)((u64)(val)), ((u64)(val))>>32)
|
|
|
|
#define wrmsr_safe(msr, a, b) paravirt_write_msr(msr, a, b)
|
2006-12-07 01:14:07 +00:00
|
|
|
|
|
|
|
/* rdmsr with exception handling */
|
2008-03-23 08:03:00 +00:00
|
|
|
#define rdmsr_safe(msr, a, b) \
|
|
|
|
({ \
|
2007-05-02 17:27:14 +00:00
|
|
|
int _err; \
|
|
|
|
u64 _l = paravirt_read_msr(msr, &_err); \
|
|
|
|
(*a) = (u32)_l; \
|
|
|
|
(*b) = _l >> 32; \
|
2008-03-23 08:03:00 +00:00
|
|
|
_err; \
|
|
|
|
})
|
2006-12-07 01:14:07 +00:00
|
|
|
|
2008-03-22 09:59:28 +00:00
|
|
|
static inline int rdmsrl_safe(unsigned msr, unsigned long long *p)
|
|
|
|
{
|
|
|
|
int err;
|
|
|
|
|
|
|
|
*p = paravirt_read_msr(msr, &err);
|
|
|
|
return err;
|
|
|
|
}
|
2007-05-02 17:27:14 +00:00
|
|
|
|
|
|
|
static inline u64 paravirt_read_tsc(void)
|
|
|
|
{
|
2007-10-16 18:51:29 +00:00
|
|
|
return PVOP_CALL0(u64, pv_cpu_ops.read_tsc);
|
2007-05-02 17:27:14 +00:00
|
|
|
}
|
2006-12-07 01:14:07 +00:00
|
|
|
|
2008-03-23 08:03:00 +00:00
|
|
|
#define rdtscl(low) \
|
|
|
|
do { \
|
2007-05-02 17:27:14 +00:00
|
|
|
u64 _l = paravirt_read_tsc(); \
|
|
|
|
low = (int)_l; \
|
2008-03-23 08:03:00 +00:00
|
|
|
} while (0)
|
2006-12-07 01:14:07 +00:00
|
|
|
|
2007-05-02 17:27:14 +00:00
|
|
|
#define rdtscll(val) (val = paravirt_read_tsc())
|
2006-12-07 01:14:07 +00:00
|
|
|
|
2007-07-18 01:37:04 +00:00
|
|
|
static inline unsigned long long paravirt_sched_clock(void)
|
|
|
|
{
|
2007-10-16 18:51:29 +00:00
|
|
|
return PVOP_CALL0(unsigned long long, pv_time_ops.sched_clock);
|
2007-07-18 01:37:04 +00:00
|
|
|
}
|
2007-10-16 18:51:29 +00:00
|
|
|
#define calculate_cpu_khz() (pv_time_ops.get_cpu_khz())
|
2007-03-05 08:30:35 +00:00
|
|
|
|
2007-05-02 17:27:14 +00:00
|
|
|
static inline unsigned long long paravirt_read_pmc(int counter)
|
|
|
|
{
|
2007-10-16 18:51:29 +00:00
|
|
|
return PVOP_CALL1(u64, pv_cpu_ops.read_pmc, counter);
|
2007-05-02 17:27:14 +00:00
|
|
|
}
|
2006-12-07 01:14:07 +00:00
|
|
|
|
2008-03-23 08:03:00 +00:00
|
|
|
#define rdpmc(counter, low, high) \
|
|
|
|
do { \
|
2007-05-02 17:27:14 +00:00
|
|
|
u64 _l = paravirt_read_pmc(counter); \
|
|
|
|
low = (u32)_l; \
|
|
|
|
high = _l >> 32; \
|
2008-03-23 08:03:00 +00:00
|
|
|
} while (0)
|
2007-05-02 17:27:13 +00:00
|
|
|
|
2008-01-30 12:32:05 +00:00
|
|
|
static inline unsigned long long paravirt_rdtscp(unsigned int *aux)
|
|
|
|
{
|
|
|
|
return PVOP_CALL1(u64, pv_cpu_ops.read_tscp, aux);
|
|
|
|
}
|
|
|
|
|
|
|
|
#define rdtscp(low, high, aux) \
|
|
|
|
do { \
|
|
|
|
int __aux; \
|
|
|
|
unsigned long __val = paravirt_rdtscp(&__aux); \
|
|
|
|
(low) = (u32)__val; \
|
|
|
|
(high) = (u32)(__val >> 32); \
|
|
|
|
(aux) = __aux; \
|
|
|
|
} while (0)
|
|
|
|
|
|
|
|
#define rdtscpll(val, aux) \
|
|
|
|
do { \
|
|
|
|
unsigned long __aux; \
|
|
|
|
val = paravirt_rdtscp(&__aux); \
|
|
|
|
(aux) = __aux; \
|
|
|
|
} while (0)
|
|
|
|
|
2007-05-02 17:27:14 +00:00
|
|
|
static inline void load_TR_desc(void)
|
|
|
|
{
|
2007-10-16 18:51:29 +00:00
|
|
|
PVOP_VCALL0(pv_cpu_ops.load_tr_desc);
|
2007-05-02 17:27:14 +00:00
|
|
|
}
|
2008-01-30 12:31:12 +00:00
|
|
|
static inline void load_gdt(const struct desc_ptr *dtr)
|
2007-05-02 17:27:14 +00:00
|
|
|
{
|
2007-10-16 18:51:29 +00:00
|
|
|
PVOP_VCALL1(pv_cpu_ops.load_gdt, dtr);
|
2007-05-02 17:27:14 +00:00
|
|
|
}
|
2008-01-30 12:31:12 +00:00
|
|
|
static inline void load_idt(const struct desc_ptr *dtr)
|
2007-05-02 17:27:14 +00:00
|
|
|
{
|
2007-10-16 18:51:29 +00:00
|
|
|
PVOP_VCALL1(pv_cpu_ops.load_idt, dtr);
|
2007-05-02 17:27:14 +00:00
|
|
|
}
|
|
|
|
static inline void set_ldt(const void *addr, unsigned entries)
|
|
|
|
{
|
2007-10-16 18:51:29 +00:00
|
|
|
PVOP_VCALL2(pv_cpu_ops.set_ldt, addr, entries);
|
2007-05-02 17:27:14 +00:00
|
|
|
}
|
2008-01-30 12:31:12 +00:00
|
|
|
static inline void store_gdt(struct desc_ptr *dtr)
|
2007-05-02 17:27:14 +00:00
|
|
|
{
|
2007-10-16 18:51:29 +00:00
|
|
|
PVOP_VCALL1(pv_cpu_ops.store_gdt, dtr);
|
2007-05-02 17:27:14 +00:00
|
|
|
}
|
2008-01-30 12:31:12 +00:00
|
|
|
static inline void store_idt(struct desc_ptr *dtr)
|
2007-05-02 17:27:14 +00:00
|
|
|
{
|
2007-10-16 18:51:29 +00:00
|
|
|
PVOP_VCALL1(pv_cpu_ops.store_idt, dtr);
|
2007-05-02 17:27:14 +00:00
|
|
|
}
|
|
|
|
static inline unsigned long paravirt_store_tr(void)
|
|
|
|
{
|
2007-10-16 18:51:29 +00:00
|
|
|
return PVOP_CALL0(unsigned long, pv_cpu_ops.store_tr);
|
2007-05-02 17:27:14 +00:00
|
|
|
}
|
|
|
|
#define store_tr(tr) ((tr) = paravirt_store_tr())
|
|
|
|
static inline void load_TLS(struct thread_struct *t, unsigned cpu)
|
|
|
|
{
|
2007-10-16 18:51:29 +00:00
|
|
|
PVOP_VCALL2(pv_cpu_ops.load_tls, t, cpu);
|
2007-05-02 17:27:14 +00:00
|
|
|
}
|
2008-01-30 12:31:13 +00:00
|
|
|
|
|
|
|
static inline void write_ldt_entry(struct desc_struct *dt, int entry,
|
|
|
|
const void *desc)
|
2007-05-02 17:27:14 +00:00
|
|
|
{
|
2008-01-30 12:31:13 +00:00
|
|
|
PVOP_VCALL3(pv_cpu_ops.write_ldt_entry, dt, entry, desc);
|
2007-05-02 17:27:14 +00:00
|
|
|
}
|
2008-01-30 12:31:13 +00:00
|
|
|
|
|
|
|
static inline void write_gdt_entry(struct desc_struct *dt, int entry,
|
|
|
|
void *desc, int type)
|
2007-05-02 17:27:14 +00:00
|
|
|
{
|
2008-01-30 12:31:13 +00:00
|
|
|
PVOP_VCALL4(pv_cpu_ops.write_gdt_entry, dt, entry, desc, type);
|
2007-05-02 17:27:14 +00:00
|
|
|
}
|
2008-01-30 12:31:13 +00:00
|
|
|
|
2008-01-30 12:31:12 +00:00
|
|
|
static inline void write_idt_entry(gate_desc *dt, int entry, const gate_desc *g)
|
2007-05-02 17:27:14 +00:00
|
|
|
{
|
2008-01-30 12:31:12 +00:00
|
|
|
PVOP_VCALL3(pv_cpu_ops.write_idt_entry, dt, entry, g);
|
2007-05-02 17:27:14 +00:00
|
|
|
}
|
|
|
|
static inline void set_iopl_mask(unsigned mask)
|
|
|
|
{
|
2007-10-16 18:51:29 +00:00
|
|
|
PVOP_VCALL1(pv_cpu_ops.set_iopl_mask, mask);
|
2007-05-02 17:27:14 +00:00
|
|
|
}
|
2007-05-02 17:27:13 +00:00
|
|
|
|
2006-12-07 01:14:07 +00:00
|
|
|
/* The paravirtualized I/O functions */
|
2008-03-23 08:03:00 +00:00
|
|
|
static inline void slow_down_io(void)
|
|
|
|
{
|
2007-10-16 18:51:29 +00:00
|
|
|
pv_cpu_ops.io_delay();
|
2006-12-07 01:14:07 +00:00
|
|
|
#ifdef REALLY_SLOW_IO
|
2007-10-16 18:51:29 +00:00
|
|
|
pv_cpu_ops.io_delay();
|
|
|
|
pv_cpu_ops.io_delay();
|
|
|
|
pv_cpu_ops.io_delay();
|
2006-12-07 01:14:07 +00:00
|
|
|
#endif
|
|
|
|
}
|
|
|
|
|
2006-12-07 01:14:08 +00:00
|
|
|
#ifdef CONFIG_X86_LOCAL_APIC
|
|
|
|
/*
|
|
|
|
* Basic functions accessing APICs.
|
|
|
|
*/
|
2008-01-30 12:30:15 +00:00
|
|
|
static inline void apic_write(unsigned long reg, u32 v)
|
2006-12-07 01:14:08 +00:00
|
|
|
{
|
2007-10-16 18:51:29 +00:00
|
|
|
PVOP_VCALL2(pv_apic_ops.apic_write, reg, v);
|
2006-12-07 01:14:08 +00:00
|
|
|
}
|
|
|
|
|
2008-01-30 12:30:15 +00:00
|
|
|
static inline void apic_write_atomic(unsigned long reg, u32 v)
|
2006-12-07 01:14:08 +00:00
|
|
|
{
|
2007-10-16 18:51:29 +00:00
|
|
|
PVOP_VCALL2(pv_apic_ops.apic_write_atomic, reg, v);
|
2006-12-07 01:14:08 +00:00
|
|
|
}
|
|
|
|
|
2008-01-30 12:30:15 +00:00
|
|
|
static inline u32 apic_read(unsigned long reg)
|
2006-12-07 01:14:08 +00:00
|
|
|
{
|
2007-10-16 18:51:29 +00:00
|
|
|
return PVOP_CALL1(unsigned long, pv_apic_ops.apic_read, reg);
|
2006-12-07 01:14:08 +00:00
|
|
|
}
|
2007-02-13 12:26:21 +00:00
|
|
|
|
|
|
|
static inline void setup_boot_clock(void)
|
|
|
|
{
|
2007-10-16 18:51:29 +00:00
|
|
|
PVOP_VCALL0(pv_apic_ops.setup_boot_clock);
|
2007-02-13 12:26:21 +00:00
|
|
|
}
|
|
|
|
|
|
|
|
static inline void setup_secondary_clock(void)
|
|
|
|
{
|
2007-10-16 18:51:29 +00:00
|
|
|
PVOP_VCALL0(pv_apic_ops.setup_secondary_clock);
|
2007-02-13 12:26:21 +00:00
|
|
|
}
|
2006-12-07 01:14:08 +00:00
|
|
|
#endif
|
|
|
|
|
2007-07-18 01:37:03 +00:00
|
|
|
static inline void paravirt_post_allocator_init(void)
|
|
|
|
{
|
2007-10-16 18:51:29 +00:00
|
|
|
if (pv_init_ops.post_allocator_init)
|
|
|
|
(*pv_init_ops.post_allocator_init)();
|
2007-07-18 01:37:03 +00:00
|
|
|
}
|
|
|
|
|
[PATCH] i386: PARAVIRT: Hooks to set up initial pagetable
This patch introduces paravirt_ops hooks to control how the kernel's
initial pagetable is set up.
In the case of a native boot, the very early bootstrap code creates a
simple non-PAE pagetable to map the kernel and physical memory. When
the VM subsystem is initialized, it creates a proper pagetable which
respects the PAE mode, large pages, etc.
When booting under a hypervisor, there are many possibilities for what
paging environment the hypervisor establishes for the guest kernel, so
the constructon of the kernel's pagetable depends on the hypervisor.
In the case of Xen, the hypervisor boots the kernel with a fully
constructed pagetable, which is already using PAE if necessary. Also,
Xen requires particular care when constructing pagetables to make sure
all pagetables are always mapped read-only.
In order to make this easier, kernel's initial pagetable construction
has been changed to only allocate and initialize a pagetable page if
there's no page already present in the pagetable. This allows the Xen
paravirt backend to make a copy of the hypervisor-provided pagetable,
allowing the kernel to establish any more mappings it needs while
keeping the existing ones.
A slightly subtle point which is worth highlighting here is that Xen
requires all kernel mappings to share the same pte_t pages between all
pagetables, so that updating a kernel page's mapping in one pagetable
is reflected in all other pagetables. This makes it possible to
allocate a page and attach it to a pagetable without having to
explicitly enumerate that page's mapping in all pagetables.
And:
+From: "Eric W. Biederman" <ebiederm@xmission.com>
If we don't set the leaf page table entries it is quite possible that
will inherit and incorrect page table entry from the initial boot
page table setup in head.S. So we need to redo the effort here,
so we pick up PSE, PGE and the like.
Hypervisors like Xen require that their page tables be read-only,
which is slightly incompatible with our low identity mappings, however
I discussed this with Jeremy he has modified the Xen early set_pte
function to avoid problems in this area.
Signed-off-by: Eric W. Biederman <ebiederm@xmission.com>
Signed-off-by: Jeremy Fitzhardinge <jeremy@xensource.com>
Signed-off-by: Andi Kleen <ak@suse.de>
Acked-by: William Irwin <bill.irwin@oracle.com>
Cc: Ingo Molnar <mingo@elte.hu>
2007-05-02 17:27:13 +00:00
|
|
|
static inline void paravirt_pagetable_setup_start(pgd_t *base)
|
|
|
|
{
|
2007-10-16 18:51:29 +00:00
|
|
|
(*pv_mmu_ops.pagetable_setup_start)(base);
|
[PATCH] i386: PARAVIRT: Hooks to set up initial pagetable
This patch introduces paravirt_ops hooks to control how the kernel's
initial pagetable is set up.
In the case of a native boot, the very early bootstrap code creates a
simple non-PAE pagetable to map the kernel and physical memory. When
the VM subsystem is initialized, it creates a proper pagetable which
respects the PAE mode, large pages, etc.
When booting under a hypervisor, there are many possibilities for what
paging environment the hypervisor establishes for the guest kernel, so
the constructon of the kernel's pagetable depends on the hypervisor.
In the case of Xen, the hypervisor boots the kernel with a fully
constructed pagetable, which is already using PAE if necessary. Also,
Xen requires particular care when constructing pagetables to make sure
all pagetables are always mapped read-only.
In order to make this easier, kernel's initial pagetable construction
has been changed to only allocate and initialize a pagetable page if
there's no page already present in the pagetable. This allows the Xen
paravirt backend to make a copy of the hypervisor-provided pagetable,
allowing the kernel to establish any more mappings it needs while
keeping the existing ones.
A slightly subtle point which is worth highlighting here is that Xen
requires all kernel mappings to share the same pte_t pages between all
pagetables, so that updating a kernel page's mapping in one pagetable
is reflected in all other pagetables. This makes it possible to
allocate a page and attach it to a pagetable without having to
explicitly enumerate that page's mapping in all pagetables.
And:
+From: "Eric W. Biederman" <ebiederm@xmission.com>
If we don't set the leaf page table entries it is quite possible that
will inherit and incorrect page table entry from the initial boot
page table setup in head.S. So we need to redo the effort here,
so we pick up PSE, PGE and the like.
Hypervisors like Xen require that their page tables be read-only,
which is slightly incompatible with our low identity mappings, however
I discussed this with Jeremy he has modified the Xen early set_pte
function to avoid problems in this area.
Signed-off-by: Eric W. Biederman <ebiederm@xmission.com>
Signed-off-by: Jeremy Fitzhardinge <jeremy@xensource.com>
Signed-off-by: Andi Kleen <ak@suse.de>
Acked-by: William Irwin <bill.irwin@oracle.com>
Cc: Ingo Molnar <mingo@elte.hu>
2007-05-02 17:27:13 +00:00
|
|
|
}
|
|
|
|
|
|
|
|
static inline void paravirt_pagetable_setup_done(pgd_t *base)
|
|
|
|
{
|
2007-10-16 18:51:29 +00:00
|
|
|
(*pv_mmu_ops.pagetable_setup_done)(base);
|
[PATCH] i386: PARAVIRT: Hooks to set up initial pagetable
This patch introduces paravirt_ops hooks to control how the kernel's
initial pagetable is set up.
In the case of a native boot, the very early bootstrap code creates a
simple non-PAE pagetable to map the kernel and physical memory. When
the VM subsystem is initialized, it creates a proper pagetable which
respects the PAE mode, large pages, etc.
When booting under a hypervisor, there are many possibilities for what
paging environment the hypervisor establishes for the guest kernel, so
the constructon of the kernel's pagetable depends on the hypervisor.
In the case of Xen, the hypervisor boots the kernel with a fully
constructed pagetable, which is already using PAE if necessary. Also,
Xen requires particular care when constructing pagetables to make sure
all pagetables are always mapped read-only.
In order to make this easier, kernel's initial pagetable construction
has been changed to only allocate and initialize a pagetable page if
there's no page already present in the pagetable. This allows the Xen
paravirt backend to make a copy of the hypervisor-provided pagetable,
allowing the kernel to establish any more mappings it needs while
keeping the existing ones.
A slightly subtle point which is worth highlighting here is that Xen
requires all kernel mappings to share the same pte_t pages between all
pagetables, so that updating a kernel page's mapping in one pagetable
is reflected in all other pagetables. This makes it possible to
allocate a page and attach it to a pagetable without having to
explicitly enumerate that page's mapping in all pagetables.
And:
+From: "Eric W. Biederman" <ebiederm@xmission.com>
If we don't set the leaf page table entries it is quite possible that
will inherit and incorrect page table entry from the initial boot
page table setup in head.S. So we need to redo the effort here,
so we pick up PSE, PGE and the like.
Hypervisors like Xen require that their page tables be read-only,
which is slightly incompatible with our low identity mappings, however
I discussed this with Jeremy he has modified the Xen early set_pte
function to avoid problems in this area.
Signed-off-by: Eric W. Biederman <ebiederm@xmission.com>
Signed-off-by: Jeremy Fitzhardinge <jeremy@xensource.com>
Signed-off-by: Andi Kleen <ak@suse.de>
Acked-by: William Irwin <bill.irwin@oracle.com>
Cc: Ingo Molnar <mingo@elte.hu>
2007-05-02 17:27:13 +00:00
|
|
|
}
|
2007-05-02 17:27:13 +00:00
|
|
|
|
2007-02-13 12:26:21 +00:00
|
|
|
#ifdef CONFIG_SMP
|
|
|
|
static inline void startup_ipi_hook(int phys_apicid, unsigned long start_eip,
|
|
|
|
unsigned long start_esp)
|
|
|
|
{
|
2007-10-16 18:51:29 +00:00
|
|
|
PVOP_VCALL3(pv_apic_ops.startup_ipi_hook,
|
|
|
|
phys_apicid, start_eip, start_esp);
|
2007-02-13 12:26:21 +00:00
|
|
|
}
|
|
|
|
#endif
|
2006-12-07 01:14:08 +00:00
|
|
|
|
2007-05-02 17:27:14 +00:00
|
|
|
static inline void paravirt_activate_mm(struct mm_struct *prev,
|
|
|
|
struct mm_struct *next)
|
|
|
|
{
|
2007-10-16 18:51:29 +00:00
|
|
|
PVOP_VCALL2(pv_mmu_ops.activate_mm, prev, next);
|
2007-05-02 17:27:14 +00:00
|
|
|
}
|
|
|
|
|
|
|
|
static inline void arch_dup_mmap(struct mm_struct *oldmm,
|
|
|
|
struct mm_struct *mm)
|
|
|
|
{
|
2007-10-16 18:51:29 +00:00
|
|
|
PVOP_VCALL2(pv_mmu_ops.dup_mmap, oldmm, mm);
|
2007-05-02 17:27:14 +00:00
|
|
|
}
|
|
|
|
|
|
|
|
static inline void arch_exit_mmap(struct mm_struct *mm)
|
|
|
|
{
|
2007-10-16 18:51:29 +00:00
|
|
|
PVOP_VCALL1(pv_mmu_ops.exit_mmap, mm);
|
2007-05-02 17:27:14 +00:00
|
|
|
}
|
|
|
|
|
2007-05-02 17:27:14 +00:00
|
|
|
static inline void __flush_tlb(void)
|
|
|
|
{
|
2007-10-16 18:51:29 +00:00
|
|
|
PVOP_VCALL0(pv_mmu_ops.flush_tlb_user);
|
2007-05-02 17:27:14 +00:00
|
|
|
}
|
|
|
|
static inline void __flush_tlb_global(void)
|
|
|
|
{
|
2007-10-16 18:51:29 +00:00
|
|
|
PVOP_VCALL0(pv_mmu_ops.flush_tlb_kernel);
|
2007-05-02 17:27:14 +00:00
|
|
|
}
|
|
|
|
static inline void __flush_tlb_single(unsigned long addr)
|
|
|
|
{
|
2007-10-16 18:51:29 +00:00
|
|
|
PVOP_VCALL1(pv_mmu_ops.flush_tlb_single, addr);
|
2007-05-02 17:27:14 +00:00
|
|
|
}
|
2006-12-07 01:14:08 +00:00
|
|
|
|
2007-05-02 17:27:15 +00:00
|
|
|
static inline void flush_tlb_others(cpumask_t cpumask, struct mm_struct *mm,
|
|
|
|
unsigned long va)
|
|
|
|
{
|
2007-10-16 18:51:29 +00:00
|
|
|
PVOP_VCALL3(pv_mmu_ops.flush_tlb_others, &cpumask, mm, va);
|
2007-05-02 17:27:15 +00:00
|
|
|
}
|
|
|
|
|
2008-06-25 04:19:12 +00:00
|
|
|
static inline int paravirt_pgd_alloc(struct mm_struct *mm)
|
|
|
|
{
|
|
|
|
return PVOP_CALL1(int, pv_mmu_ops.pgd_alloc, mm);
|
|
|
|
}
|
|
|
|
|
|
|
|
static inline void paravirt_pgd_free(struct mm_struct *mm, pgd_t *pgd)
|
|
|
|
{
|
|
|
|
PVOP_VCALL2(pv_mmu_ops.pgd_free, mm, pgd);
|
|
|
|
}
|
|
|
|
|
2008-03-17 23:37:01 +00:00
|
|
|
static inline void paravirt_alloc_pte(struct mm_struct *mm, unsigned pfn)
|
2007-05-02 17:27:14 +00:00
|
|
|
{
|
2008-03-17 23:37:01 +00:00
|
|
|
PVOP_VCALL2(pv_mmu_ops.alloc_pte, mm, pfn);
|
2007-05-02 17:27:14 +00:00
|
|
|
}
|
2008-03-17 23:37:01 +00:00
|
|
|
static inline void paravirt_release_pte(unsigned pfn)
|
2007-05-02 17:27:14 +00:00
|
|
|
{
|
2008-03-17 23:37:01 +00:00
|
|
|
PVOP_VCALL1(pv_mmu_ops.release_pte, pfn);
|
2007-05-02 17:27:14 +00:00
|
|
|
}
|
2007-02-13 12:26:21 +00:00
|
|
|
|
2008-03-17 23:37:01 +00:00
|
|
|
static inline void paravirt_alloc_pmd(struct mm_struct *mm, unsigned pfn)
|
2007-05-02 17:27:14 +00:00
|
|
|
{
|
2008-03-17 23:37:01 +00:00
|
|
|
PVOP_VCALL2(pv_mmu_ops.alloc_pmd, mm, pfn);
|
2007-05-02 17:27:14 +00:00
|
|
|
}
|
2007-02-13 12:26:21 +00:00
|
|
|
|
2008-03-17 23:37:01 +00:00
|
|
|
static inline void paravirt_alloc_pmd_clone(unsigned pfn, unsigned clonepfn,
|
|
|
|
unsigned start, unsigned count)
|
2007-05-02 17:27:14 +00:00
|
|
|
{
|
2008-03-17 23:37:01 +00:00
|
|
|
PVOP_VCALL4(pv_mmu_ops.alloc_pmd_clone, pfn, clonepfn, start, count);
|
2007-05-02 17:27:14 +00:00
|
|
|
}
|
2008-03-17 23:37:01 +00:00
|
|
|
static inline void paravirt_release_pmd(unsigned pfn)
|
2006-12-07 01:14:08 +00:00
|
|
|
{
|
2008-03-17 23:37:01 +00:00
|
|
|
PVOP_VCALL1(pv_mmu_ops.release_pmd, pfn);
|
2006-12-07 01:14:08 +00:00
|
|
|
}
|
|
|
|
|
2008-03-17 23:37:02 +00:00
|
|
|
static inline void paravirt_alloc_pud(struct mm_struct *mm, unsigned pfn)
|
|
|
|
{
|
|
|
|
PVOP_VCALL2(pv_mmu_ops.alloc_pud, mm, pfn);
|
|
|
|
}
|
|
|
|
static inline void paravirt_release_pud(unsigned pfn)
|
|
|
|
{
|
|
|
|
PVOP_VCALL1(pv_mmu_ops.release_pud, pfn);
|
|
|
|
}
|
|
|
|
|
2007-05-02 17:27:15 +00:00
|
|
|
#ifdef CONFIG_HIGHPTE
|
|
|
|
static inline void *kmap_atomic_pte(struct page *page, enum km_type type)
|
|
|
|
{
|
|
|
|
unsigned long ret;
|
2007-10-16 18:51:29 +00:00
|
|
|
ret = PVOP_CALL2(unsigned long, pv_mmu_ops.kmap_atomic_pte, page, type);
|
2007-05-02 17:27:15 +00:00
|
|
|
return (void *)ret;
|
|
|
|
}
|
|
|
|
#endif
|
|
|
|
|
2007-05-02 17:27:14 +00:00
|
|
|
static inline void pte_update(struct mm_struct *mm, unsigned long addr,
|
|
|
|
pte_t *ptep)
|
2006-12-07 01:14:08 +00:00
|
|
|
{
|
2007-10-16 18:51:29 +00:00
|
|
|
PVOP_VCALL3(pv_mmu_ops.pte_update, mm, addr, ptep);
|
2006-12-07 01:14:08 +00:00
|
|
|
}
|
|
|
|
|
2007-05-02 17:27:14 +00:00
|
|
|
static inline void pte_update_defer(struct mm_struct *mm, unsigned long addr,
|
|
|
|
pte_t *ptep)
|
2006-12-07 01:14:08 +00:00
|
|
|
{
|
2007-10-16 18:51:29 +00:00
|
|
|
PVOP_VCALL3(pv_mmu_ops.pte_update_defer, mm, addr, ptep);
|
2006-12-07 01:14:08 +00:00
|
|
|
}
|
|
|
|
|
2008-01-30 12:33:15 +00:00
|
|
|
static inline pte_t __pte(pteval_t val)
|
2006-12-07 01:14:08 +00:00
|
|
|
{
|
2008-01-30 12:33:15 +00:00
|
|
|
pteval_t ret;
|
|
|
|
|
|
|
|
if (sizeof(pteval_t) > sizeof(long))
|
|
|
|
ret = PVOP_CALL2(pteval_t,
|
|
|
|
pv_mmu_ops.make_pte,
|
|
|
|
val, (u64)val >> 32);
|
|
|
|
else
|
|
|
|
ret = PVOP_CALL1(pteval_t,
|
|
|
|
pv_mmu_ops.make_pte,
|
|
|
|
val);
|
|
|
|
|
2008-01-30 12:32:57 +00:00
|
|
|
return (pte_t) { .pte = ret };
|
2006-12-07 01:14:08 +00:00
|
|
|
}
|
|
|
|
|
2008-01-30 12:33:15 +00:00
|
|
|
static inline pteval_t pte_val(pte_t pte)
|
|
|
|
{
|
|
|
|
pteval_t ret;
|
|
|
|
|
|
|
|
if (sizeof(pteval_t) > sizeof(long))
|
|
|
|
ret = PVOP_CALL2(pteval_t, pv_mmu_ops.pte_val,
|
|
|
|
pte.pte, (u64)pte.pte >> 32);
|
|
|
|
else
|
|
|
|
ret = PVOP_CALL1(pteval_t, pv_mmu_ops.pte_val,
|
|
|
|
pte.pte);
|
|
|
|
|
|
|
|
return ret;
|
|
|
|
}
|
|
|
|
|
2008-05-26 22:31:06 +00:00
|
|
|
static inline pteval_t pte_flags(pte_t pte)
|
|
|
|
{
|
|
|
|
pteval_t ret;
|
|
|
|
|
|
|
|
if (sizeof(pteval_t) > sizeof(long))
|
|
|
|
ret = PVOP_CALL2(pteval_t, pv_mmu_ops.pte_flags,
|
|
|
|
pte.pte, (u64)pte.pte >> 32);
|
|
|
|
else
|
|
|
|
ret = PVOP_CALL1(pteval_t, pv_mmu_ops.pte_flags,
|
|
|
|
pte.pte);
|
|
|
|
|
|
|
|
return ret;
|
|
|
|
}
|
|
|
|
|
2008-01-30 12:33:15 +00:00
|
|
|
static inline pgd_t __pgd(pgdval_t val)
|
2006-12-07 01:14:08 +00:00
|
|
|
{
|
2008-01-30 12:33:15 +00:00
|
|
|
pgdval_t ret;
|
|
|
|
|
|
|
|
if (sizeof(pgdval_t) > sizeof(long))
|
|
|
|
ret = PVOP_CALL2(pgdval_t, pv_mmu_ops.make_pgd,
|
|
|
|
val, (u64)val >> 32);
|
|
|
|
else
|
|
|
|
ret = PVOP_CALL1(pgdval_t, pv_mmu_ops.make_pgd,
|
|
|
|
val);
|
|
|
|
|
|
|
|
return (pgd_t) { ret };
|
|
|
|
}
|
|
|
|
|
|
|
|
static inline pgdval_t pgd_val(pgd_t pgd)
|
|
|
|
{
|
|
|
|
pgdval_t ret;
|
|
|
|
|
|
|
|
if (sizeof(pgdval_t) > sizeof(long))
|
|
|
|
ret = PVOP_CALL2(pgdval_t, pv_mmu_ops.pgd_val,
|
|
|
|
pgd.pgd, (u64)pgd.pgd >> 32);
|
|
|
|
else
|
|
|
|
ret = PVOP_CALL1(pgdval_t, pv_mmu_ops.pgd_val,
|
|
|
|
pgd.pgd);
|
|
|
|
|
|
|
|
return ret;
|
2007-05-02 17:27:14 +00:00
|
|
|
}
|
|
|
|
|
2008-06-16 11:30:01 +00:00
|
|
|
#define __HAVE_ARCH_PTEP_MODIFY_PROT_TRANSACTION
|
|
|
|
static inline pte_t ptep_modify_prot_start(struct mm_struct *mm, unsigned long addr,
|
|
|
|
pte_t *ptep)
|
|
|
|
{
|
|
|
|
pteval_t ret;
|
|
|
|
|
|
|
|
ret = PVOP_CALL3(pteval_t, pv_mmu_ops.ptep_modify_prot_start,
|
|
|
|
mm, addr, ptep);
|
|
|
|
|
|
|
|
return (pte_t) { .pte = ret };
|
|
|
|
}
|
|
|
|
|
|
|
|
static inline void ptep_modify_prot_commit(struct mm_struct *mm, unsigned long addr,
|
|
|
|
pte_t *ptep, pte_t pte)
|
|
|
|
{
|
|
|
|
if (sizeof(pteval_t) > sizeof(long))
|
|
|
|
/* 5 arg words */
|
|
|
|
pv_mmu_ops.ptep_modify_prot_commit(mm, addr, ptep, pte);
|
|
|
|
else
|
|
|
|
PVOP_VCALL4(pv_mmu_ops.ptep_modify_prot_commit,
|
|
|
|
mm, addr, ptep, pte.pte);
|
|
|
|
}
|
|
|
|
|
2008-01-30 12:33:15 +00:00
|
|
|
static inline void set_pte(pte_t *ptep, pte_t pte)
|
|
|
|
{
|
|
|
|
if (sizeof(pteval_t) > sizeof(long))
|
|
|
|
PVOP_VCALL3(pv_mmu_ops.set_pte, ptep,
|
|
|
|
pte.pte, (u64)pte.pte >> 32);
|
|
|
|
else
|
|
|
|
PVOP_VCALL2(pv_mmu_ops.set_pte, ptep,
|
|
|
|
pte.pte);
|
|
|
|
}
|
|
|
|
|
|
|
|
static inline void set_pte_at(struct mm_struct *mm, unsigned long addr,
|
|
|
|
pte_t *ptep, pte_t pte)
|
|
|
|
{
|
|
|
|
if (sizeof(pteval_t) > sizeof(long))
|
|
|
|
/* 5 arg words */
|
|
|
|
pv_mmu_ops.set_pte_at(mm, addr, ptep, pte);
|
|
|
|
else
|
|
|
|
PVOP_VCALL4(pv_mmu_ops.set_pte_at, mm, addr, ptep, pte.pte);
|
|
|
|
}
|
|
|
|
|
2008-01-30 12:33:15 +00:00
|
|
|
static inline void set_pmd(pmd_t *pmdp, pmd_t pmd)
|
|
|
|
{
|
|
|
|
pmdval_t val = native_pmd_val(pmd);
|
|
|
|
|
|
|
|
if (sizeof(pmdval_t) > sizeof(long))
|
|
|
|
PVOP_VCALL3(pv_mmu_ops.set_pmd, pmdp, val, (u64)val >> 32);
|
|
|
|
else
|
|
|
|
PVOP_VCALL2(pv_mmu_ops.set_pmd, pmdp, val);
|
|
|
|
}
|
|
|
|
|
2008-01-30 12:33:19 +00:00
|
|
|
#if PAGETABLE_LEVELS >= 3
|
|
|
|
static inline pmd_t __pmd(pmdval_t val)
|
|
|
|
{
|
|
|
|
pmdval_t ret;
|
|
|
|
|
|
|
|
if (sizeof(pmdval_t) > sizeof(long))
|
|
|
|
ret = PVOP_CALL2(pmdval_t, pv_mmu_ops.make_pmd,
|
|
|
|
val, (u64)val >> 32);
|
|
|
|
else
|
|
|
|
ret = PVOP_CALL1(pmdval_t, pv_mmu_ops.make_pmd,
|
|
|
|
val);
|
|
|
|
|
|
|
|
return (pmd_t) { ret };
|
|
|
|
}
|
|
|
|
|
|
|
|
static inline pmdval_t pmd_val(pmd_t pmd)
|
|
|
|
{
|
|
|
|
pmdval_t ret;
|
|
|
|
|
|
|
|
if (sizeof(pmdval_t) > sizeof(long))
|
|
|
|
ret = PVOP_CALL2(pmdval_t, pv_mmu_ops.pmd_val,
|
|
|
|
pmd.pmd, (u64)pmd.pmd >> 32);
|
|
|
|
else
|
|
|
|
ret = PVOP_CALL1(pmdval_t, pv_mmu_ops.pmd_val,
|
|
|
|
pmd.pmd);
|
|
|
|
|
|
|
|
return ret;
|
|
|
|
}
|
|
|
|
|
|
|
|
static inline void set_pud(pud_t *pudp, pud_t pud)
|
|
|
|
{
|
|
|
|
pudval_t val = native_pud_val(pud);
|
|
|
|
|
|
|
|
if (sizeof(pudval_t) > sizeof(long))
|
|
|
|
PVOP_VCALL3(pv_mmu_ops.set_pud, pudp,
|
|
|
|
val, (u64)val >> 32);
|
|
|
|
else
|
|
|
|
PVOP_VCALL2(pv_mmu_ops.set_pud, pudp,
|
|
|
|
val);
|
|
|
|
}
|
2008-01-30 12:33:20 +00:00
|
|
|
#if PAGETABLE_LEVELS == 4
|
|
|
|
static inline pud_t __pud(pudval_t val)
|
|
|
|
{
|
|
|
|
pudval_t ret;
|
|
|
|
|
|
|
|
if (sizeof(pudval_t) > sizeof(long))
|
|
|
|
ret = PVOP_CALL2(pudval_t, pv_mmu_ops.make_pud,
|
|
|
|
val, (u64)val >> 32);
|
|
|
|
else
|
|
|
|
ret = PVOP_CALL1(pudval_t, pv_mmu_ops.make_pud,
|
|
|
|
val);
|
|
|
|
|
|
|
|
return (pud_t) { ret };
|
|
|
|
}
|
|
|
|
|
|
|
|
static inline pudval_t pud_val(pud_t pud)
|
|
|
|
{
|
|
|
|
pudval_t ret;
|
|
|
|
|
|
|
|
if (sizeof(pudval_t) > sizeof(long))
|
|
|
|
ret = PVOP_CALL2(pudval_t, pv_mmu_ops.pud_val,
|
|
|
|
pud.pud, (u64)pud.pud >> 32);
|
|
|
|
else
|
|
|
|
ret = PVOP_CALL1(pudval_t, pv_mmu_ops.pud_val,
|
|
|
|
pud.pud);
|
|
|
|
|
|
|
|
return ret;
|
|
|
|
}
|
|
|
|
|
|
|
|
static inline void set_pgd(pgd_t *pgdp, pgd_t pgd)
|
|
|
|
{
|
|
|
|
pgdval_t val = native_pgd_val(pgd);
|
|
|
|
|
|
|
|
if (sizeof(pgdval_t) > sizeof(long))
|
|
|
|
PVOP_VCALL3(pv_mmu_ops.set_pgd, pgdp,
|
|
|
|
val, (u64)val >> 32);
|
|
|
|
else
|
|
|
|
PVOP_VCALL2(pv_mmu_ops.set_pgd, pgdp,
|
|
|
|
val);
|
|
|
|
}
|
|
|
|
|
|
|
|
static inline void pgd_clear(pgd_t *pgdp)
|
|
|
|
{
|
|
|
|
set_pgd(pgdp, __pgd(0));
|
|
|
|
}
|
|
|
|
|
|
|
|
static inline void pud_clear(pud_t *pudp)
|
|
|
|
{
|
|
|
|
set_pud(pudp, __pud(0));
|
|
|
|
}
|
|
|
|
|
|
|
|
#endif /* PAGETABLE_LEVELS == 4 */
|
|
|
|
|
2008-01-30 12:33:19 +00:00
|
|
|
#endif /* PAGETABLE_LEVELS >= 3 */
|
|
|
|
|
2008-01-30 12:33:15 +00:00
|
|
|
#ifdef CONFIG_X86_PAE
|
|
|
|
/* Special-case pte-setting operations for PAE, which can't update a
|
|
|
|
64-bit pte atomically */
|
|
|
|
static inline void set_pte_atomic(pte_t *ptep, pte_t pte)
|
|
|
|
{
|
|
|
|
PVOP_VCALL3(pv_mmu_ops.set_pte_atomic, ptep,
|
|
|
|
pte.pte, pte.pte >> 32);
|
|
|
|
}
|
|
|
|
|
|
|
|
static inline void set_pte_present(struct mm_struct *mm, unsigned long addr,
|
|
|
|
pte_t *ptep, pte_t pte)
|
|
|
|
{
|
|
|
|
/* 5 arg words */
|
|
|
|
pv_mmu_ops.set_pte_present(mm, addr, ptep, pte);
|
|
|
|
}
|
|
|
|
|
|
|
|
static inline void pte_clear(struct mm_struct *mm, unsigned long addr,
|
|
|
|
pte_t *ptep)
|
|
|
|
{
|
|
|
|
PVOP_VCALL3(pv_mmu_ops.pte_clear, mm, addr, ptep);
|
|
|
|
}
|
2008-01-30 12:33:15 +00:00
|
|
|
|
|
|
|
static inline void pmd_clear(pmd_t *pmdp)
|
|
|
|
{
|
|
|
|
PVOP_VCALL1(pv_mmu_ops.pmd_clear, pmdp);
|
|
|
|
}
|
2008-01-30 12:33:15 +00:00
|
|
|
#else /* !CONFIG_X86_PAE */
|
|
|
|
static inline void set_pte_atomic(pte_t *ptep, pte_t pte)
|
|
|
|
{
|
|
|
|
set_pte(ptep, pte);
|
|
|
|
}
|
|
|
|
|
|
|
|
static inline void set_pte_present(struct mm_struct *mm, unsigned long addr,
|
|
|
|
pte_t *ptep, pte_t pte)
|
|
|
|
{
|
|
|
|
set_pte(ptep, pte);
|
|
|
|
}
|
|
|
|
|
|
|
|
static inline void pte_clear(struct mm_struct *mm, unsigned long addr,
|
|
|
|
pte_t *ptep)
|
|
|
|
{
|
|
|
|
set_pte_at(mm, addr, ptep, __pte(0));
|
|
|
|
}
|
2008-01-30 12:33:15 +00:00
|
|
|
|
|
|
|
static inline void pmd_clear(pmd_t *pmdp)
|
|
|
|
{
|
|
|
|
set_pmd(pmdp, __pmd(0));
|
|
|
|
}
|
2008-01-30 12:33:15 +00:00
|
|
|
#endif /* CONFIG_X86_PAE */
|
|
|
|
|
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: Jeremy 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>
2007-10-16 18:51:29 +00:00
|
|
|
/* Lazy mode for batching updates / context switch */
|
|
|
|
enum paravirt_lazy_mode {
|
|
|
|
PARAVIRT_LAZY_NONE,
|
|
|
|
PARAVIRT_LAZY_MMU,
|
|
|
|
PARAVIRT_LAZY_CPU,
|
|
|
|
};
|
|
|
|
|
|
|
|
enum paravirt_lazy_mode paravirt_get_lazy_mode(void);
|
|
|
|
void paravirt_enter_lazy_cpu(void);
|
|
|
|
void paravirt_leave_lazy_cpu(void);
|
|
|
|
void paravirt_enter_lazy_mmu(void);
|
|
|
|
void paravirt_leave_lazy_mmu(void);
|
|
|
|
void paravirt_leave_lazy(enum paravirt_lazy_mode mode);
|
|
|
|
|
2007-02-13 12:26:21 +00:00
|
|
|
#define __HAVE_ARCH_ENTER_LAZY_CPU_MODE
|
2007-05-02 17:27:14 +00:00
|
|
|
static inline void arch_enter_lazy_cpu_mode(void)
|
|
|
|
{
|
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: Jeremy 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>
2007-10-16 18:51:29 +00:00
|
|
|
PVOP_VCALL0(pv_cpu_ops.lazy_mode.enter);
|
2007-05-02 17:27:14 +00:00
|
|
|
}
|
|
|
|
|
|
|
|
static inline void arch_leave_lazy_cpu_mode(void)
|
|
|
|
{
|
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: Jeremy 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>
2007-10-16 18:51:29 +00:00
|
|
|
PVOP_VCALL0(pv_cpu_ops.lazy_mode.leave);
|
2007-05-02 17:27:14 +00:00
|
|
|
}
|
|
|
|
|
|
|
|
static inline void arch_flush_lazy_cpu_mode(void)
|
|
|
|
{
|
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: Jeremy 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>
2007-10-16 18:51:29 +00:00
|
|
|
if (unlikely(paravirt_get_lazy_mode() == PARAVIRT_LAZY_CPU)) {
|
|
|
|
arch_leave_lazy_cpu_mode();
|
|
|
|
arch_enter_lazy_cpu_mode();
|
|
|
|
}
|
2007-05-02 17:27:14 +00:00
|
|
|
}
|
|
|
|
|
2007-02-13 12:26:21 +00:00
|
|
|
|
|
|
|
#define __HAVE_ARCH_ENTER_LAZY_MMU_MODE
|
2007-05-02 17:27:14 +00:00
|
|
|
static inline void arch_enter_lazy_mmu_mode(void)
|
|
|
|
{
|
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: Jeremy 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>
2007-10-16 18:51:29 +00:00
|
|
|
PVOP_VCALL0(pv_mmu_ops.lazy_mode.enter);
|
2007-05-02 17:27:14 +00:00
|
|
|
}
|
|
|
|
|
|
|
|
static inline void arch_leave_lazy_mmu_mode(void)
|
|
|
|
{
|
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: Jeremy 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>
2007-10-16 18:51:29 +00:00
|
|
|
PVOP_VCALL0(pv_mmu_ops.lazy_mode.leave);
|
2007-05-02 17:27:14 +00:00
|
|
|
}
|
|
|
|
|
|
|
|
static inline void arch_flush_lazy_mmu_mode(void)
|
|
|
|
{
|
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: Jeremy 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>
2007-10-16 18:51:29 +00:00
|
|
|
if (unlikely(paravirt_get_lazy_mode() == PARAVIRT_LAZY_MMU)) {
|
|
|
|
arch_leave_lazy_mmu_mode();
|
|
|
|
arch_enter_lazy_mmu_mode();
|
|
|
|
}
|
2007-05-02 17:27:14 +00:00
|
|
|
}
|
2007-02-13 12:26:21 +00:00
|
|
|
|
2008-06-17 18:42:01 +00:00
|
|
|
static inline void __set_fixmap(unsigned /* enum fixed_addresses */ idx,
|
|
|
|
unsigned long phys, pgprot_t flags)
|
|
|
|
{
|
|
|
|
pv_mmu_ops.set_fixmap(idx, phys, flags);
|
|
|
|
}
|
|
|
|
|
2007-05-02 17:27:13 +00:00
|
|
|
void _paravirt_nop(void);
|
|
|
|
#define paravirt_nop ((void *)_paravirt_nop)
|
|
|
|
|
2006-12-07 01:14:08 +00:00
|
|
|
/* These all sit in the .parainstructions section to tell us what to patch. */
|
2007-05-02 17:27:14 +00:00
|
|
|
struct paravirt_patch_site {
|
2006-12-07 01:14:08 +00:00
|
|
|
u8 *instr; /* original instructions */
|
|
|
|
u8 instrtype; /* type of this instruction */
|
|
|
|
u8 len; /* length of original instruction */
|
|
|
|
u16 clobbers; /* what registers you may clobber */
|
|
|
|
};
|
|
|
|
|
2007-05-02 17:27:14 +00:00
|
|
|
extern struct paravirt_patch_site __parainstructions[],
|
|
|
|
__parainstructions_end[];
|
|
|
|
|
2008-01-30 12:32:07 +00:00
|
|
|
#ifdef CONFIG_X86_32
|
|
|
|
#define PV_SAVE_REGS "pushl %%ecx; pushl %%edx;"
|
|
|
|
#define PV_RESTORE_REGS "popl %%edx; popl %%ecx"
|
|
|
|
#define PV_FLAGS_ARG "0"
|
|
|
|
#define PV_EXTRA_CLOBBERS
|
|
|
|
#define PV_VEXTRA_CLOBBERS
|
|
|
|
#else
|
|
|
|
/* We save some registers, but all of them, that's too much. We clobber all
|
|
|
|
* caller saved registers but the argument parameter */
|
|
|
|
#define PV_SAVE_REGS "pushq %%rdi;"
|
|
|
|
#define PV_RESTORE_REGS "popq %%rdi;"
|
|
|
|
#define PV_EXTRA_CLOBBERS EXTRA_CLOBBERS, "rcx" , "rdx"
|
|
|
|
#define PV_VEXTRA_CLOBBERS EXTRA_CLOBBERS, "rdi", "rcx" , "rdx"
|
|
|
|
#define PV_FLAGS_ARG "D"
|
|
|
|
#endif
|
|
|
|
|
2006-12-07 01:14:08 +00:00
|
|
|
static inline unsigned long __raw_local_save_flags(void)
|
|
|
|
{
|
|
|
|
unsigned long f;
|
|
|
|
|
2008-01-30 12:32:07 +00:00
|
|
|
asm volatile(paravirt_alt(PV_SAVE_REGS
|
2007-05-02 17:27:14 +00:00
|
|
|
PARAVIRT_CALL
|
2008-01-30 12:32:07 +00:00
|
|
|
PV_RESTORE_REGS)
|
2007-05-02 17:27:14 +00:00
|
|
|
: "=a"(f)
|
2007-10-16 18:51:29 +00:00
|
|
|
: paravirt_type(pv_irq_ops.save_fl),
|
2007-05-02 17:27:14 +00:00
|
|
|
paravirt_clobber(CLBR_EAX)
|
2008-01-30 12:32:07 +00:00
|
|
|
: "memory", "cc" PV_VEXTRA_CLOBBERS);
|
2006-12-07 01:14:08 +00:00
|
|
|
return f;
|
|
|
|
}
|
|
|
|
|
|
|
|
static inline void raw_local_irq_restore(unsigned long f)
|
|
|
|
{
|
2008-01-30 12:32:07 +00:00
|
|
|
asm volatile(paravirt_alt(PV_SAVE_REGS
|
2007-05-02 17:27:14 +00:00
|
|
|
PARAVIRT_CALL
|
2008-01-30 12:32:07 +00:00
|
|
|
PV_RESTORE_REGS)
|
2007-05-02 17:27:14 +00:00
|
|
|
: "=a"(f)
|
2008-01-30 12:32:07 +00:00
|
|
|
: PV_FLAGS_ARG(f),
|
2007-10-16 18:51:29 +00:00
|
|
|
paravirt_type(pv_irq_ops.restore_fl),
|
2007-05-02 17:27:14 +00:00
|
|
|
paravirt_clobber(CLBR_EAX)
|
2008-01-30 12:32:07 +00:00
|
|
|
: "memory", "cc" PV_EXTRA_CLOBBERS);
|
2006-12-07 01:14:08 +00:00
|
|
|
}
|
|
|
|
|
|
|
|
static inline void raw_local_irq_disable(void)
|
|
|
|
{
|
2008-01-30 12:32:07 +00:00
|
|
|
asm volatile(paravirt_alt(PV_SAVE_REGS
|
2007-05-02 17:27:14 +00:00
|
|
|
PARAVIRT_CALL
|
2008-01-30 12:32:07 +00:00
|
|
|
PV_RESTORE_REGS)
|
2007-05-02 17:27:14 +00:00
|
|
|
:
|
2007-10-16 18:51:29 +00:00
|
|
|
: paravirt_type(pv_irq_ops.irq_disable),
|
2007-05-02 17:27:14 +00:00
|
|
|
paravirt_clobber(CLBR_EAX)
|
2008-01-30 12:32:07 +00:00
|
|
|
: "memory", "eax", "cc" PV_EXTRA_CLOBBERS);
|
2006-12-07 01:14:08 +00:00
|
|
|
}
|
|
|
|
|
|
|
|
static inline void raw_local_irq_enable(void)
|
|
|
|
{
|
2008-01-30 12:32:07 +00:00
|
|
|
asm volatile(paravirt_alt(PV_SAVE_REGS
|
2007-05-02 17:27:14 +00:00
|
|
|
PARAVIRT_CALL
|
2008-01-30 12:32:07 +00:00
|
|
|
PV_RESTORE_REGS)
|
2007-05-02 17:27:14 +00:00
|
|
|
:
|
2007-10-16 18:51:29 +00:00
|
|
|
: paravirt_type(pv_irq_ops.irq_enable),
|
2007-05-02 17:27:14 +00:00
|
|
|
paravirt_clobber(CLBR_EAX)
|
2008-01-30 12:32:07 +00:00
|
|
|
: "memory", "eax", "cc" PV_EXTRA_CLOBBERS);
|
2006-12-07 01:14:08 +00:00
|
|
|
}
|
|
|
|
|
|
|
|
static inline unsigned long __raw_local_irq_save(void)
|
|
|
|
{
|
|
|
|
unsigned long f;
|
|
|
|
|
2007-05-02 17:27:14 +00:00
|
|
|
f = __raw_local_save_flags();
|
|
|
|
raw_local_irq_disable();
|
2006-12-07 01:14:08 +00:00
|
|
|
return f;
|
|
|
|
}
|
|
|
|
|
2007-05-02 17:27:14 +00:00
|
|
|
/* Make sure as little as possible of this mess escapes. */
|
2007-05-02 17:27:14 +00:00
|
|
|
#undef PARAVIRT_CALL
|
2007-05-02 17:27:15 +00:00
|
|
|
#undef __PVOP_CALL
|
|
|
|
#undef __PVOP_VCALL
|
2007-05-02 17:27:14 +00:00
|
|
|
#undef PVOP_VCALL0
|
|
|
|
#undef PVOP_CALL0
|
|
|
|
#undef PVOP_VCALL1
|
|
|
|
#undef PVOP_CALL1
|
|
|
|
#undef PVOP_VCALL2
|
|
|
|
#undef PVOP_CALL2
|
|
|
|
#undef PVOP_VCALL3
|
|
|
|
#undef PVOP_CALL3
|
|
|
|
#undef PVOP_VCALL4
|
|
|
|
#undef PVOP_CALL4
|
2006-12-07 01:14:08 +00:00
|
|
|
|
2006-12-07 01:14:07 +00:00
|
|
|
#else /* __ASSEMBLY__ */
|
|
|
|
|
2008-01-30 12:32:06 +00:00
|
|
|
#define _PVSITE(ptype, clobbers, ops, word, algn) \
|
2006-12-07 01:14:08 +00:00
|
|
|
771:; \
|
|
|
|
ops; \
|
|
|
|
772:; \
|
|
|
|
.pushsection .parainstructions,"a"; \
|
2008-01-30 12:32:06 +00:00
|
|
|
.align algn; \
|
|
|
|
word 771b; \
|
2006-12-07 01:14:08 +00:00
|
|
|
.byte ptype; \
|
|
|
|
.byte 772b-771b; \
|
|
|
|
.short clobbers; \
|
|
|
|
.popsection
|
|
|
|
|
2008-01-30 12:32:06 +00:00
|
|
|
|
|
|
|
#ifdef CONFIG_X86_64
|
2008-01-30 12:32:06 +00:00
|
|
|
#define PV_SAVE_REGS pushq %rax; pushq %rdi; pushq %rcx; pushq %rdx
|
|
|
|
#define PV_RESTORE_REGS popq %rdx; popq %rcx; popq %rdi; popq %rax
|
|
|
|
#define PARA_PATCH(struct, off) ((PARAVIRT_PATCH_##struct + (off)) / 8)
|
2008-01-30 12:32:06 +00:00
|
|
|
#define PARA_SITE(ptype, clobbers, ops) _PVSITE(ptype, clobbers, ops, .quad, 8)
|
2008-06-25 04:19:15 +00:00
|
|
|
#define PARA_INDIRECT(addr) *addr(%rip)
|
2008-01-30 12:32:06 +00:00
|
|
|
#else
|
2008-01-30 12:32:06 +00:00
|
|
|
#define PV_SAVE_REGS pushl %eax; pushl %edi; pushl %ecx; pushl %edx
|
|
|
|
#define PV_RESTORE_REGS popl %edx; popl %ecx; popl %edi; popl %eax
|
|
|
|
#define PARA_PATCH(struct, off) ((PARAVIRT_PATCH_##struct + (off)) / 4)
|
2008-01-30 12:32:06 +00:00
|
|
|
#define PARA_SITE(ptype, clobbers, ops) _PVSITE(ptype, clobbers, ops, .long, 4)
|
2008-06-25 04:19:15 +00:00
|
|
|
#define PARA_INDIRECT(addr) *%cs:addr
|
2008-01-30 12:32:06 +00:00
|
|
|
#endif
|
|
|
|
|
2007-10-16 18:51:29 +00:00
|
|
|
#define INTERRUPT_RETURN \
|
|
|
|
PARA_SITE(PARA_PATCH(pv_cpu_ops, PV_CPU_iret), CLBR_NONE, \
|
2008-06-25 04:19:15 +00:00
|
|
|
jmp PARA_INDIRECT(pv_cpu_ops+PV_CPU_iret))
|
2007-05-02 17:27:14 +00:00
|
|
|
|
|
|
|
#define DISABLE_INTERRUPTS(clobbers) \
|
2007-10-16 18:51:29 +00:00
|
|
|
PARA_SITE(PARA_PATCH(pv_irq_ops, PV_IRQ_irq_disable), clobbers, \
|
2008-06-25 04:19:15 +00:00
|
|
|
PV_SAVE_REGS; \
|
|
|
|
call PARA_INDIRECT(pv_irq_ops+PV_IRQ_irq_disable); \
|
2008-01-30 12:32:06 +00:00
|
|
|
PV_RESTORE_REGS;) \
|
2007-05-02 17:27:14 +00:00
|
|
|
|
|
|
|
#define ENABLE_INTERRUPTS(clobbers) \
|
2007-10-16 18:51:29 +00:00
|
|
|
PARA_SITE(PARA_PATCH(pv_irq_ops, PV_IRQ_irq_enable), clobbers, \
|
2008-06-25 04:19:15 +00:00
|
|
|
PV_SAVE_REGS; \
|
|
|
|
call PARA_INDIRECT(pv_irq_ops+PV_IRQ_irq_enable); \
|
2008-01-30 12:32:06 +00:00
|
|
|
PV_RESTORE_REGS;)
|
2007-05-02 17:27:14 +00:00
|
|
|
|
2008-06-25 04:19:28 +00:00
|
|
|
#define USERGS_SYSRET32 \
|
|
|
|
PARA_SITE(PARA_PATCH(pv_cpu_ops, PV_CPU_usergs_sysret32), \
|
2008-01-30 12:30:33 +00:00
|
|
|
CLBR_NONE, \
|
2008-06-25 04:19:28 +00:00
|
|
|
jmp PARA_INDIRECT(pv_cpu_ops+PV_CPU_usergs_sysret32))
|
2008-01-30 12:32:07 +00:00
|
|
|
|
2008-01-30 12:32:06 +00:00
|
|
|
#ifdef CONFIG_X86_32
|
2008-06-25 04:19:15 +00:00
|
|
|
#define GET_CR0_INTO_EAX \
|
|
|
|
push %ecx; push %edx; \
|
|
|
|
call PARA_INDIRECT(pv_cpu_ops+PV_CPU_read_cr0); \
|
2007-05-02 17:27:14 +00:00
|
|
|
pop %edx; pop %ecx
|
2008-06-25 04:19:28 +00:00
|
|
|
|
|
|
|
#define ENABLE_INTERRUPTS_SYSEXIT \
|
|
|
|
PARA_SITE(PARA_PATCH(pv_cpu_ops, PV_CPU_irq_enable_sysexit), \
|
|
|
|
CLBR_NONE, \
|
|
|
|
jmp PARA_INDIRECT(pv_cpu_ops+PV_CPU_irq_enable_sysexit))
|
|
|
|
|
|
|
|
|
|
|
|
#else /* !CONFIG_X86_32 */
|
2008-06-25 04:19:30 +00:00
|
|
|
|
|
|
|
/*
|
|
|
|
* If swapgs is used while the userspace stack is still current,
|
|
|
|
* there's no way to call a pvop. The PV replacement *must* be
|
|
|
|
* inlined, or the swapgs instruction must be trapped and emulated.
|
|
|
|
*/
|
|
|
|
#define SWAPGS_UNSAFE_STACK \
|
|
|
|
PARA_SITE(PARA_PATCH(pv_cpu_ops, PV_CPU_swapgs), CLBR_NONE, \
|
|
|
|
swapgs)
|
|
|
|
|
2008-01-30 12:32:08 +00:00
|
|
|
#define SWAPGS \
|
|
|
|
PARA_SITE(PARA_PATCH(pv_cpu_ops, PV_CPU_swapgs), CLBR_NONE, \
|
|
|
|
PV_SAVE_REGS; \
|
2008-06-25 04:19:15 +00:00
|
|
|
call PARA_INDIRECT(pv_cpu_ops+PV_CPU_swapgs); \
|
2008-01-30 12:32:08 +00:00
|
|
|
PV_RESTORE_REGS \
|
|
|
|
)
|
|
|
|
|
2008-06-25 04:19:15 +00:00
|
|
|
#define GET_CR2_INTO_RCX \
|
|
|
|
call PARA_INDIRECT(pv_mmu_ops+PV_MMU_read_cr2); \
|
|
|
|
movq %rax, %rcx; \
|
2008-01-30 12:32:07 +00:00
|
|
|
xorq %rax, %rax;
|
|
|
|
|
2008-06-25 04:19:28 +00:00
|
|
|
#define USERGS_SYSRET64 \
|
|
|
|
PARA_SITE(PARA_PATCH(pv_cpu_ops, PV_CPU_usergs_sysret64), \
|
2008-06-25 04:19:26 +00:00
|
|
|
CLBR_NONE, \
|
2008-06-25 04:19:28 +00:00
|
|
|
jmp PARA_INDIRECT(pv_cpu_ops+PV_CPU_usergs_sysret64))
|
|
|
|
|
|
|
|
#define ENABLE_INTERRUPTS_SYSEXIT32 \
|
|
|
|
PARA_SITE(PARA_PATCH(pv_cpu_ops, PV_CPU_irq_enable_sysexit), \
|
|
|
|
CLBR_NONE, \
|
|
|
|
jmp PARA_INDIRECT(pv_cpu_ops+PV_CPU_irq_enable_sysexit))
|
|
|
|
#endif /* CONFIG_X86_32 */
|
2006-12-07 01:14:08 +00:00
|
|
|
|
2006-12-07 01:14:07 +00:00
|
|
|
#endif /* __ASSEMBLY__ */
|
|
|
|
#endif /* CONFIG_PARAVIRT */
|
|
|
|
#endif /* __ASM_PARAVIRT_H */
|