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>
|
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. */
|
|
|
|
|
#define CLBR_NONE 0x0
|
|
|
|
|
#define CLBR_EAX 0x1
|
|
|
|
|
#define CLBR_ECX 0x2
|
|
|
|
|
#define CLBR_EDX 0x4
|
|
|
|
|
#define CLBR_ANY 0x7
|
|
|
|
|
|
2006-12-07 01:14:07 +00:00
|
|
|
#ifndef __ASSEMBLY__
|
2007-05-02 17:27:13 +00:00
|
|
|
#include <linux/types.h>
|
|
|
|
|
|
2006-12-07 01:14:07 +00:00
|
|
|
struct thread_struct;
|
|
|
|
|
struct Xgt_desc_struct;
|
|
|
|
|
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;
|
2006-12-07 01:14:07 +00:00
|
|
|
struct paravirt_ops
|
|
|
|
|
{
|
|
|
|
|
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;
|
2006-12-07 01:14:07 +00:00
|
|
|
int paravirt_enabled;
|
|
|
|
|
const char *name;
|
|
|
|
|
|
2006-12-07 01:14:08 +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.
|
|
|
|
|
*/
|
|
|
|
|
unsigned (*patch)(u8 type, u16 clobber, void *firstinsn, unsigned len);
|
|
|
|
|
|
2006-12-07 01:14:07 +00:00
|
|
|
void (*arch_setup)(void);
|
|
|
|
|
char *(*memory_setup)(void);
|
|
|
|
|
void (*init_IRQ)(void);
|
|
|
|
|
|
[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
|
|
|
void (*pagetable_setup_start)(pgd_t *pgd_base);
|
|
|
|
|
void (*pagetable_setup_done)(pgd_t *pgd_base);
|
|
|
|
|
|
2006-12-07 01:14:07 +00:00
|
|
|
void (*banner)(void);
|
|
|
|
|
|
|
|
|
|
unsigned long (*get_wallclock)(void);
|
|
|
|
|
int (*set_wallclock)(unsigned long);
|
|
|
|
|
void (*time_init)(void);
|
|
|
|
|
|
2007-02-13 12:26:25 +00:00
|
|
|
void (*cpuid)(unsigned int *eax, unsigned int *ebx,
|
2006-12-07 01:14:07 +00:00
|
|
|
unsigned int *ecx, unsigned int *edx);
|
|
|
|
|
|
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_cr2)(void);
|
|
|
|
|
void (*write_cr2)(unsigned long);
|
2006-12-07 01:14:07 +00:00
|
|
|
|
2007-02-13 12:26:25 +00:00
|
|
|
unsigned long (*read_cr3)(void);
|
|
|
|
|
void (*write_cr3)(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
|
|
|
|
2007-02-13 12:26:25 +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);
|
|
|
|
|
void (*wbinvd)(void);
|
2006-12-07 01:14:07 +00:00
|
|
|
|
|
|
|
|
/* err = 0/-EFAULT. wrmsr returns 0/-EFAULT. */
|
2007-02-13 12:26:25 +00:00
|
|
|
u64 (*read_msr)(unsigned int msr, int *err);
|
|
|
|
|
int (*write_msr)(unsigned int msr, u64 val);
|
|
|
|
|
|
|
|
|
|
u64 (*read_tsc)(void);
|
|
|
|
|
u64 (*read_pmc)(void);
|
2007-03-05 08:30:35 +00:00
|
|
|
u64 (*get_scheduled_cycles)(void);
|
2007-03-05 08:30:36 +00:00
|
|
|
unsigned long (*get_cpu_khz)(void);
|
2007-02-13 12:26:25 +00:00
|
|
|
|
|
|
|
|
void (*load_tr_desc)(void);
|
|
|
|
|
void (*load_gdt)(const struct Xgt_desc_struct *);
|
|
|
|
|
void (*load_idt)(const struct Xgt_desc_struct *);
|
|
|
|
|
void (*store_gdt)(struct Xgt_desc_struct *);
|
|
|
|
|
void (*store_idt)(struct Xgt_desc_struct *);
|
|
|
|
|
void (*set_ldt)(const void *desc, unsigned entries);
|
|
|
|
|
unsigned long (*store_tr)(void);
|
|
|
|
|
void (*load_tls)(struct thread_struct *t, unsigned int cpu);
|
2007-05-02 17:27:10 +00:00
|
|
|
void (*write_ldt_entry)(struct desc_struct *,
|
|
|
|
|
int entrynum, u32 low, u32 high);
|
|
|
|
|
void (*write_gdt_entry)(struct desc_struct *,
|
|
|
|
|
int entrynum, u32 low, u32 high);
|
|
|
|
|
void (*write_idt_entry)(struct desc_struct *,
|
|
|
|
|
int entrynum, u32 low, u32 high);
|
|
|
|
|
void (*load_esp0)(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);
|
2006-12-07 01:14:07 +00:00
|
|
|
|
2007-02-13 12:26:25 +00:00
|
|
|
void (*io_delay)(void);
|
2006-12-07 01:14:07 +00:00
|
|
|
|
2007-05-02 17:27:14 +00:00
|
|
|
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
|
|
|
#ifdef CONFIG_X86_LOCAL_APIC
|
2007-02-13 12:26:25 +00:00
|
|
|
void (*apic_write)(unsigned long reg, unsigned long v);
|
|
|
|
|
void (*apic_write_atomic)(unsigned long reg, unsigned long v);
|
|
|
|
|
unsigned long (*apic_read)(unsigned long reg);
|
2007-02-13 12:26:21 +00:00
|
|
|
void (*setup_boot_clock)(void);
|
|
|
|
|
void (*setup_secondary_clock)(void);
|
2006-12-07 01:14:08 +00:00
|
|
|
#endif
|
|
|
|
|
|
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-02-13 12:26:25 +00:00
|
|
|
|
2007-03-14 09:18:09 +00:00
|
|
|
void (*map_pt_hook)(int type, pte_t *va, u32 pfn);
|
2007-03-05 08:30:37 +00:00
|
|
|
|
2007-02-13 12:26:25 +00:00
|
|
|
void (*alloc_pt)(u32 pfn);
|
|
|
|
|
void (*alloc_pd)(u32 pfn);
|
|
|
|
|
void (*alloc_pd_clone)(u32 pfn, u32 clonepfn, u32 start, u32 count);
|
|
|
|
|
void (*release_pt)(u32 pfn);
|
|
|
|
|
void (*release_pd)(u32 pfn);
|
|
|
|
|
|
|
|
|
|
void (*set_pte)(pte_t *ptep, pte_t pteval);
|
2007-05-02 17:27:13 +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);
|
2007-05-02 17:27:13 +00:00
|
|
|
void (*pte_update)(struct mm_struct *mm, unsigned long addr, pte_t *ptep);
|
|
|
|
|
void (*pte_update_defer)(struct mm_struct *mm, unsigned long addr, pte_t *ptep);
|
|
|
|
|
|
|
|
|
|
pte_t (*ptep_get_and_clear)(pte_t *ptep);
|
|
|
|
|
|
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-05-02 17:27:13 +00:00
|
|
|
void (*set_pte_present)(struct mm_struct *mm, unsigned long addr, pte_t *ptep, pte_t pte);
|
2007-02-13 12:26:25 +00:00
|
|
|
void (*set_pud)(pud_t *pudp, pud_t pudval);
|
2007-05-02 17:27:13 +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
|
|
|
|
|
|
|
|
unsigned long long (*pte_val)(pte_t);
|
|
|
|
|
unsigned long long (*pmd_val)(pmd_t);
|
|
|
|
|
unsigned long long (*pgd_val)(pgd_t);
|
|
|
|
|
|
|
|
|
|
pte_t (*make_pte)(unsigned long long pte);
|
|
|
|
|
pmd_t (*make_pmd)(unsigned long long pmd);
|
|
|
|
|
pgd_t (*make_pgd)(unsigned long long pgd);
|
|
|
|
|
#else
|
|
|
|
|
unsigned long (*pte_val)(pte_t);
|
|
|
|
|
unsigned long (*pgd_val)(pgd_t);
|
|
|
|
|
|
|
|
|
|
pte_t (*make_pte)(unsigned long pte);
|
|
|
|
|
pgd_t (*make_pgd)(unsigned long pgd);
|
2006-12-07 01:14:08 +00:00
|
|
|
#endif
|
|
|
|
|
|
2007-02-13 12:26:25 +00:00
|
|
|
void (*set_lazy_mode)(int mode);
|
2007-02-13 12:26:21 +00:00
|
|
|
|
2006-12-07 01:14:07 +00:00
|
|
|
/* These two are jmp to, not actually called. */
|
2007-02-13 12:26:25 +00:00
|
|
|
void (*irq_enable_sysexit)(void);
|
|
|
|
|
void (*iret)(void);
|
2007-02-13 12:26:21 +00:00
|
|
|
|
2007-02-13 12:26:25 +00:00
|
|
|
void (*startup_ipi_hook)(int phys_apicid, unsigned long start_eip, unsigned long start_esp);
|
2006-12-07 01:14:07 +00:00
|
|
|
};
|
|
|
|
|
|
2006-12-07 01:14:08 +00:00
|
|
|
/* Mark a paravirt probe function. */
|
|
|
|
|
#define paravirt_probe(fn) \
|
|
|
|
|
static asmlinkage void (*__paravirtprobe_##fn)(void) __attribute_used__ \
|
|
|
|
|
__attribute__((__section__(".paravirtprobe"))) = fn
|
|
|
|
|
|
2006-12-07 01:14:07 +00:00
|
|
|
extern struct paravirt_ops paravirt_ops;
|
|
|
|
|
|
2007-05-02 17:27:14 +00:00
|
|
|
#define PARAVIRT_PATCH(x) \
|
|
|
|
|
(offsetof(struct paravirt_ops, x) / sizeof(void *))
|
|
|
|
|
|
|
|
|
|
#define paravirt_type(type) \
|
|
|
|
|
[paravirt_typenum] "i" (PARAVIRT_PATCH(type))
|
|
|
|
|
#define paravirt_clobber(clobber) \
|
|
|
|
|
[paravirt_clobber] "i" (clobber)
|
|
|
|
|
|
2007-05-02 17:27:14 +00:00
|
|
|
#define PARAVIRT_CALL "call *(paravirt_ops+%c[paravirt_typenum]*4);"
|
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" \
|
|
|
|
|
" .long 771b\n" \
|
|
|
|
|
" .byte " type "\n" \
|
|
|
|
|
" .byte 772b-771b\n" \
|
|
|
|
|
" .short " clobber "\n" \
|
|
|
|
|
".popsection\n"
|
|
|
|
|
|
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]")
|
|
|
|
|
|
2007-05-02 17:27:14 +00:00
|
|
|
#define PVOP_CALL0(__rettype, __op) \
|
|
|
|
|
({ \
|
|
|
|
|
__rettype __ret; \
|
|
|
|
|
if (sizeof(__rettype) > sizeof(unsigned long)) { \
|
|
|
|
|
unsigned long long __tmp; \
|
|
|
|
|
unsigned long __ecx; \
|
|
|
|
|
asm volatile(paravirt_alt(PARAVIRT_CALL) \
|
|
|
|
|
: "=A" (__tmp), "=c" (__ecx) \
|
|
|
|
|
: paravirt_type(__op), \
|
|
|
|
|
paravirt_clobber(CLBR_ANY) \
|
|
|
|
|
: "memory", "cc"); \
|
|
|
|
|
__ret = (__rettype)__tmp; \
|
|
|
|
|
} else { \
|
|
|
|
|
unsigned long __tmp, __edx, __ecx; \
|
|
|
|
|
asm volatile(paravirt_alt(PARAVIRT_CALL) \
|
|
|
|
|
: "=a" (__tmp), "=d" (__edx), \
|
|
|
|
|
"=c" (__ecx) \
|
|
|
|
|
: paravirt_type(__op), \
|
|
|
|
|
paravirt_clobber(CLBR_ANY) \
|
|
|
|
|
: "memory", "cc"); \
|
|
|
|
|
__ret = (__rettype)__tmp; \
|
|
|
|
|
} \
|
|
|
|
|
__ret; \
|
|
|
|
|
})
|
|
|
|
|
#define PVOP_VCALL0(__op) \
|
|
|
|
|
({ \
|
|
|
|
|
unsigned long __eax, __edx, __ecx; \
|
|
|
|
|
asm volatile(paravirt_alt(PARAVIRT_CALL) \
|
|
|
|
|
: "=a" (__eax), "=d" (__edx), "=c" (__ecx) \
|
|
|
|
|
: paravirt_type(__op), \
|
|
|
|
|
paravirt_clobber(CLBR_ANY) \
|
|
|
|
|
: "memory", "cc"); \
|
|
|
|
|
})
|
|
|
|
|
|
|
|
|
|
#define PVOP_CALL1(__rettype, __op, arg1) \
|
|
|
|
|
({ \
|
|
|
|
|
__rettype __ret; \
|
|
|
|
|
if (sizeof(__rettype) > sizeof(unsigned long)) { \
|
|
|
|
|
unsigned long long __tmp; \
|
|
|
|
|
unsigned long __ecx; \
|
|
|
|
|
asm volatile(paravirt_alt(PARAVIRT_CALL) \
|
|
|
|
|
: "=A" (__tmp), "=c" (__ecx) \
|
|
|
|
|
: "a" ((u32)(arg1)), \
|
|
|
|
|
paravirt_type(__op), \
|
|
|
|
|
paravirt_clobber(CLBR_ANY) \
|
|
|
|
|
: "memory", "cc"); \
|
|
|
|
|
__ret = (__rettype)__tmp; \
|
|
|
|
|
} else { \
|
|
|
|
|
unsigned long __tmp, __edx, __ecx; \
|
|
|
|
|
asm volatile(paravirt_alt(PARAVIRT_CALL) \
|
|
|
|
|
: "=a" (__tmp), "=d" (__edx), \
|
|
|
|
|
"=c" (__ecx) \
|
|
|
|
|
: "0" ((u32)(arg1)), \
|
|
|
|
|
paravirt_type(__op), \
|
|
|
|
|
paravirt_clobber(CLBR_ANY) \
|
|
|
|
|
: "memory", "cc"); \
|
|
|
|
|
__ret = (__rettype)__tmp; \
|
|
|
|
|
} \
|
|
|
|
|
__ret; \
|
|
|
|
|
})
|
|
|
|
|
#define PVOP_VCALL1(__op, arg1) \
|
|
|
|
|
({ \
|
|
|
|
|
unsigned long __eax, __edx, __ecx; \
|
|
|
|
|
asm volatile(paravirt_alt(PARAVIRT_CALL) \
|
|
|
|
|
: "=a" (__eax), "=d" (__edx), "=c" (__ecx) \
|
|
|
|
|
: "0" ((u32)(arg1)), \
|
|
|
|
|
paravirt_type(__op), \
|
|
|
|
|
paravirt_clobber(CLBR_ANY) \
|
|
|
|
|
: "memory", "cc"); \
|
|
|
|
|
})
|
|
|
|
|
|
|
|
|
|
#define PVOP_CALL2(__rettype, __op, arg1, arg2) \
|
|
|
|
|
({ \
|
|
|
|
|
__rettype __ret; \
|
|
|
|
|
if (sizeof(__rettype) > sizeof(unsigned long)) { \
|
|
|
|
|
unsigned long long __tmp; \
|
|
|
|
|
unsigned long __ecx; \
|
|
|
|
|
asm volatile(paravirt_alt(PARAVIRT_CALL) \
|
|
|
|
|
: "=A" (__tmp), "=c" (__ecx) \
|
|
|
|
|
: "a" ((u32)(arg1)), \
|
|
|
|
|
"d" ((u32)(arg2)), \
|
|
|
|
|
paravirt_type(__op), \
|
|
|
|
|
paravirt_clobber(CLBR_ANY) \
|
|
|
|
|
: "memory", "cc"); \
|
|
|
|
|
__ret = (__rettype)__tmp; \
|
|
|
|
|
} else { \
|
|
|
|
|
unsigned long __tmp, __edx, __ecx; \
|
|
|
|
|
asm volatile(paravirt_alt(PARAVIRT_CALL) \
|
|
|
|
|
: "=a" (__tmp), "=d" (__edx), \
|
|
|
|
|
"=c" (__ecx) \
|
|
|
|
|
: "0" ((u32)(arg1)), \
|
|
|
|
|
"1" ((u32)(arg2)), \
|
|
|
|
|
paravirt_type(__op), \
|
|
|
|
|
paravirt_clobber(CLBR_ANY) \
|
|
|
|
|
: "memory", "cc"); \
|
|
|
|
|
__ret = (__rettype)__tmp; \
|
|
|
|
|
} \
|
|
|
|
|
__ret; \
|
|
|
|
|
})
|
|
|
|
|
#define PVOP_VCALL2(__op, arg1, arg2) \
|
|
|
|
|
({ \
|
|
|
|
|
unsigned long __eax, __edx, __ecx; \
|
|
|
|
|
asm volatile(paravirt_alt(PARAVIRT_CALL) \
|
|
|
|
|
: "=a" (__eax), "=d" (__edx), "=c" (__ecx) \
|
|
|
|
|
: "0" ((u32)(arg1)), \
|
|
|
|
|
"1" ((u32)(arg2)), \
|
|
|
|
|
paravirt_type(__op), \
|
|
|
|
|
paravirt_clobber(CLBR_ANY) \
|
|
|
|
|
: "memory", "cc"); \
|
|
|
|
|
})
|
|
|
|
|
|
|
|
|
|
#define PVOP_CALL3(__rettype, __op, arg1, arg2, arg3) \
|
|
|
|
|
({ \
|
|
|
|
|
__rettype __ret; \
|
|
|
|
|
if (sizeof(__rettype) > sizeof(unsigned long)) { \
|
|
|
|
|
unsigned long long __tmp; \
|
|
|
|
|
unsigned long __ecx; \
|
|
|
|
|
asm volatile(paravirt_alt(PARAVIRT_CALL) \
|
|
|
|
|
: "=A" (__tmp), "=c" (__ecx) \
|
|
|
|
|
: "a" ((u32)(arg1)), \
|
|
|
|
|
"d" ((u32)(arg2)), \
|
|
|
|
|
"1" ((u32)(arg3)), \
|
|
|
|
|
paravirt_type(__op), \
|
|
|
|
|
paravirt_clobber(CLBR_ANY) \
|
|
|
|
|
: "memory", "cc"); \
|
|
|
|
|
__ret = (__rettype)__tmp; \
|
|
|
|
|
} else { \
|
|
|
|
|
unsigned long __tmp, __edx, __ecx; \
|
|
|
|
|
asm volatile(paravirt_alt(PARAVIRT_CALL) \
|
|
|
|
|
: "=a" (__tmp), "=d" (__edx), \
|
|
|
|
|
"=c" (__ecx) \
|
|
|
|
|
: "0" ((u32)(arg1)), \
|
|
|
|
|
"1" ((u32)(arg2)), \
|
|
|
|
|
"2" ((u32)(arg3)), \
|
|
|
|
|
paravirt_type(__op), \
|
|
|
|
|
paravirt_clobber(CLBR_ANY) \
|
|
|
|
|
: "memory", "cc"); \
|
|
|
|
|
__ret = (__rettype)__tmp; \
|
|
|
|
|
} \
|
|
|
|
|
__ret; \
|
|
|
|
|
})
|
|
|
|
|
#define PVOP_VCALL3(__op, arg1, arg2, arg3) \
|
|
|
|
|
({ \
|
|
|
|
|
unsigned long __eax, __edx, __ecx; \
|
|
|
|
|
asm volatile(paravirt_alt(PARAVIRT_CALL) \
|
|
|
|
|
: "=a" (__eax), "=d" (__edx), "=c" (__ecx) \
|
|
|
|
|
: "0" ((u32)(arg1)), \
|
|
|
|
|
"1" ((u32)(arg2)), \
|
|
|
|
|
"2" ((u32)(arg3)), \
|
|
|
|
|
paravirt_type(__op), \
|
|
|
|
|
paravirt_clobber(CLBR_ANY) \
|
|
|
|
|
: "memory", "cc"); \
|
|
|
|
|
})
|
|
|
|
|
|
|
|
|
|
#define PVOP_CALL4(__rettype, __op, arg1, arg2, arg3, arg4) \
|
|
|
|
|
({ \
|
|
|
|
|
__rettype __ret; \
|
|
|
|
|
if (sizeof(__rettype) > sizeof(unsigned long)) { \
|
|
|
|
|
unsigned long long __tmp; \
|
|
|
|
|
unsigned long __ecx; \
|
|
|
|
|
asm volatile("push %[_arg4]; " \
|
|
|
|
|
paravirt_alt(PARAVIRT_CALL) \
|
|
|
|
|
"lea 4(%%esp),%%esp" \
|
|
|
|
|
: "=A" (__tmp), "=c" (__ecx) \
|
|
|
|
|
: "a" ((u32)(arg1)), \
|
|
|
|
|
"d" ((u32)(arg2)), \
|
|
|
|
|
"1" ((u32)(arg3)), \
|
|
|
|
|
[_arg4] "mr" ((u32)(arg4)), \
|
|
|
|
|
paravirt_type(__op), \
|
|
|
|
|
paravirt_clobber(CLBR_ANY) \
|
|
|
|
|
: "memory", "cc",); \
|
|
|
|
|
__ret = (__rettype)__tmp; \
|
|
|
|
|
} else { \
|
|
|
|
|
unsigned long __tmp, __edx, __ecx; \
|
|
|
|
|
asm volatile("push %[_arg4]; " \
|
|
|
|
|
paravirt_alt(PARAVIRT_CALL) \
|
|
|
|
|
"lea 4(%%esp),%%esp" \
|
|
|
|
|
: "=a" (__tmp), "=d" (__edx), "=c" (__ecx) \
|
|
|
|
|
: "0" ((u32)(arg1)), \
|
|
|
|
|
"1" ((u32)(arg2)), \
|
|
|
|
|
"2" ((u32)(arg3)), \
|
|
|
|
|
[_arg4]"mr" ((u32)(arg4)), \
|
|
|
|
|
paravirt_type(__op), \
|
|
|
|
|
paravirt_clobber(CLBR_ANY) \
|
|
|
|
|
: "memory", "cc"); \
|
|
|
|
|
__ret = (__rettype)__tmp; \
|
|
|
|
|
} \
|
|
|
|
|
__ret; \
|
|
|
|
|
})
|
|
|
|
|
#define PVOP_VCALL4(__op, arg1, arg2, arg3, arg4) \
|
|
|
|
|
({ \
|
|
|
|
|
unsigned long __eax, __edx, __ecx; \
|
|
|
|
|
asm volatile("push %[_arg4]; " \
|
|
|
|
|
paravirt_alt(PARAVIRT_CALL) \
|
|
|
|
|
"lea 4(%%esp),%%esp" \
|
|
|
|
|
: "=a" (__eax), "=d" (__edx), "=c" (__ecx) \
|
|
|
|
|
: "0" ((u32)(arg1)), \
|
|
|
|
|
"1" ((u32)(arg2)), \
|
|
|
|
|
"2" ((u32)(arg3)), \
|
|
|
|
|
[_arg4]"mr" ((u32)(arg4)), \
|
|
|
|
|
paravirt_type(__op), \
|
|
|
|
|
paravirt_clobber(CLBR_ANY) \
|
|
|
|
|
: "memory", "cc"); \
|
|
|
|
|
})
|
|
|
|
|
|
|
|
|
|
static inline int paravirt_enabled(void)
|
|
|
|
|
{
|
|
|
|
|
return paravirt_ops.paravirt_enabled;
|
|
|
|
|
}
|
2006-12-07 01:14:07 +00:00
|
|
|
|
|
|
|
|
static inline void load_esp0(struct tss_struct *tss,
|
|
|
|
|
struct thread_struct *thread)
|
|
|
|
|
{
|
2007-05-02 17:27:14 +00:00
|
|
|
PVOP_VCALL2(load_esp0, tss, thread);
|
2006-12-07 01:14:07 +00:00
|
|
|
}
|
|
|
|
|
|
|
|
|
|
#define ARCH_SETUP paravirt_ops.arch_setup();
|
|
|
|
|
static inline unsigned long get_wallclock(void)
|
|
|
|
|
{
|
2007-05-02 17:27:14 +00:00
|
|
|
return PVOP_CALL0(unsigned long, get_wallclock);
|
2006-12-07 01:14:07 +00:00
|
|
|
}
|
|
|
|
|
|
|
|
|
|
static inline int set_wallclock(unsigned long nowtime)
|
|
|
|
|
{
|
2007-05-02 17:27:14 +00:00
|
|
|
return PVOP_CALL1(int, 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-03-05 08:30:39 +00:00
|
|
|
return paravirt_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-05-02 17:27:14 +00:00
|
|
|
PVOP_VCALL4(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)
|
|
|
|
|
{
|
|
|
|
|
return PVOP_CALL1(unsigned long, get_debugreg, reg);
|
|
|
|
|
}
|
|
|
|
|
#define get_debugreg(var, reg) var = paravirt_get_debugreg(reg)
|
|
|
|
|
static inline void set_debugreg(unsigned long val, int reg)
|
|
|
|
|
{
|
|
|
|
|
PVOP_VCALL2(set_debugreg, reg, val);
|
|
|
|
|
}
|
2006-12-07 01:14:07 +00:00
|
|
|
|
2007-05-02 17:27:14 +00:00
|
|
|
static inline void clts(void)
|
|
|
|
|
{
|
|
|
|
|
PVOP_VCALL0(clts);
|
|
|
|
|
}
|
2006-12-07 01:14:07 +00:00
|
|
|
|
2007-05-02 17:27:14 +00:00
|
|
|
static inline unsigned long read_cr0(void)
|
|
|
|
|
{
|
|
|
|
|
return PVOP_CALL0(unsigned long, read_cr0);
|
|
|
|
|
}
|
2006-12-07 01:14:07 +00:00
|
|
|
|
2007-05-02 17:27:14 +00:00
|
|
|
static inline void write_cr0(unsigned long x)
|
|
|
|
|
{
|
|
|
|
|
PVOP_VCALL1(write_cr0, x);
|
|
|
|
|
}
|
|
|
|
|
|
|
|
|
|
static inline unsigned long read_cr2(void)
|
|
|
|
|
{
|
|
|
|
|
return PVOP_CALL0(unsigned long, read_cr2);
|
|
|
|
|
}
|
|
|
|
|
|
|
|
|
|
static inline void write_cr2(unsigned long x)
|
|
|
|
|
{
|
|
|
|
|
PVOP_VCALL1(write_cr2, x);
|
|
|
|
|
}
|
|
|
|
|
|
|
|
|
|
static inline unsigned long read_cr3(void)
|
|
|
|
|
{
|
|
|
|
|
return PVOP_CALL0(unsigned long, read_cr3);
|
|
|
|
|
}
|
2006-12-07 01:14:07 +00:00
|
|
|
|
2007-05-02 17:27:14 +00:00
|
|
|
static inline void write_cr3(unsigned long x)
|
|
|
|
|
{
|
|
|
|
|
PVOP_VCALL1(write_cr3, x);
|
|
|
|
|
}
|
2006-12-07 01:14:07 +00:00
|
|
|
|
2007-05-02 17:27:14 +00:00
|
|
|
static inline unsigned long read_cr4(void)
|
|
|
|
|
{
|
|
|
|
|
return PVOP_CALL0(unsigned long, read_cr4);
|
|
|
|
|
}
|
|
|
|
|
static inline unsigned long read_cr4_safe(void)
|
|
|
|
|
{
|
|
|
|
|
return PVOP_CALL0(unsigned long, read_cr4_safe);
|
|
|
|
|
}
|
2006-12-07 01:14:07 +00:00
|
|
|
|
2007-05-02 17:27:14 +00:00
|
|
|
static inline void write_cr4(unsigned long x)
|
|
|
|
|
{
|
|
|
|
|
PVOP_VCALL1(write_cr4, x);
|
|
|
|
|
}
|
2007-05-02 17:27:13 +00:00
|
|
|
|
2006-12-07 01:14:07 +00:00
|
|
|
static inline void raw_safe_halt(void)
|
|
|
|
|
{
|
2007-05-02 17:27:14 +00:00
|
|
|
PVOP_VCALL0(safe_halt);
|
2006-12-07 01:14:07 +00:00
|
|
|
}
|
|
|
|
|
|
|
|
|
|
static inline void halt(void)
|
|
|
|
|
{
|
2007-05-02 17:27:14 +00:00
|
|
|
PVOP_VCALL0(safe_halt);
|
|
|
|
|
}
|
|
|
|
|
|
|
|
|
|
static inline void wbinvd(void)
|
|
|
|
|
{
|
|
|
|
|
PVOP_VCALL0(wbinvd);
|
2006-12-07 01:14:07 +00:00
|
|
|
}
|
|
|
|
|
|
|
|
|
|
#define get_kernel_rpl() (paravirt_ops.kernel_rpl)
|
|
|
|
|
|
2007-05-02 17:27:14 +00:00
|
|
|
static inline u64 paravirt_read_msr(unsigned msr, int *err)
|
|
|
|
|
{
|
|
|
|
|
return PVOP_CALL2(u64, read_msr, msr, err);
|
|
|
|
|
}
|
|
|
|
|
static inline int paravirt_write_msr(unsigned msr, unsigned low, unsigned high)
|
|
|
|
|
{
|
|
|
|
|
return PVOP_CALL3(int, write_msr, msr, low, high);
|
|
|
|
|
}
|
|
|
|
|
|
2007-05-02 17:27:10 +00:00
|
|
|
/* These should all do BUG_ON(_err), but our headers are too tangled. */
|
2007-05-02 17:27:14 +00:00
|
|
|
#define rdmsr(msr,val1,val2) do { \
|
|
|
|
|
int _err; \
|
|
|
|
|
u64 _l = paravirt_read_msr(msr, &_err); \
|
|
|
|
|
val1 = (u32)_l; \
|
|
|
|
|
val2 = _l >> 32; \
|
2006-12-07 01:14:07 +00:00
|
|
|
} while(0)
|
|
|
|
|
|
2007-05-02 17:27:14 +00:00
|
|
|
#define wrmsr(msr,val1,val2) do { \
|
|
|
|
|
paravirt_write_msr(msr, val1, val2); \
|
2006-12-07 01:14:07 +00:00
|
|
|
} while(0)
|
|
|
|
|
|
2007-05-02 17:27:14 +00:00
|
|
|
#define rdmsrl(msr,val) do { \
|
|
|
|
|
int _err; \
|
|
|
|
|
val = paravirt_read_msr(msr, &_err); \
|
2006-12-07 01:14:07 +00:00
|
|
|
} while(0)
|
|
|
|
|
|
2007-05-02 17:27:14 +00:00
|
|
|
#define wrmsrl(msr,val) ((void)paravirt_write_msr(msr, val, 0))
|
|
|
|
|
#define wrmsr_safe(msr,a,b) paravirt_write_msr(msr, a, b)
|
2006-12-07 01:14:07 +00:00
|
|
|
|
|
|
|
|
/* rdmsr with exception handling */
|
2007-05-02 17:27:14 +00:00
|
|
|
#define rdmsr_safe(msr,a,b) ({ \
|
|
|
|
|
int _err; \
|
|
|
|
|
u64 _l = paravirt_read_msr(msr, &_err); \
|
|
|
|
|
(*a) = (u32)_l; \
|
|
|
|
|
(*b) = _l >> 32; \
|
2006-12-07 01:14:07 +00:00
|
|
|
_err; })
|
|
|
|
|
|
2007-05-02 17:27:14 +00:00
|
|
|
|
|
|
|
|
static inline u64 paravirt_read_tsc(void)
|
|
|
|
|
{
|
|
|
|
|
return PVOP_CALL0(u64, read_tsc);
|
|
|
|
|
}
|
|
|
|
|
#define rdtsc(low,high) do { \
|
|
|
|
|
u64 _l = paravirt_read_tsc(); \
|
|
|
|
|
low = (u32)_l; \
|
|
|
|
|
high = _l >> 32; \
|
2006-12-07 01:14:07 +00:00
|
|
|
} while(0)
|
|
|
|
|
|
2007-05-02 17:27:14 +00:00
|
|
|
#define rdtscl(low) do { \
|
|
|
|
|
u64 _l = paravirt_read_tsc(); \
|
|
|
|
|
low = (int)_l; \
|
2006-12-07 01:14:07 +00:00
|
|
|
} while(0)
|
|
|
|
|
|
2007-05-02 17:27:14 +00:00
|
|
|
#define rdtscll(val) (val = paravirt_read_tsc())
|
2006-12-07 01:14:07 +00:00
|
|
|
|
2007-03-05 08:30:35 +00:00
|
|
|
#define get_scheduled_cycles(val) (val = paravirt_ops.get_scheduled_cycles())
|
2007-03-05 08:30:36 +00:00
|
|
|
#define calculate_cpu_khz() (paravirt_ops.get_cpu_khz())
|
2007-03-05 08:30:35 +00:00
|
|
|
|
2006-12-07 01:14:07 +00:00
|
|
|
#define write_tsc(val1,val2) wrmsr(0x10, val1, val2)
|
|
|
|
|
|
2007-05-02 17:27:14 +00:00
|
|
|
static inline unsigned long long paravirt_read_pmc(int counter)
|
|
|
|
|
{
|
|
|
|
|
return PVOP_CALL1(u64, read_pmc, counter);
|
|
|
|
|
}
|
2006-12-07 01:14:07 +00:00
|
|
|
|
2007-05-02 17:27:14 +00:00
|
|
|
#define rdpmc(counter,low,high) do { \
|
|
|
|
|
u64 _l = paravirt_read_pmc(counter); \
|
|
|
|
|
low = (u32)_l; \
|
|
|
|
|
high = _l >> 32; \
|
|
|
|
|
} while(0)
|
2007-05-02 17:27:13 +00:00
|
|
|
|
2007-05-02 17:27:14 +00:00
|
|
|
static inline void load_TR_desc(void)
|
|
|
|
|
{
|
|
|
|
|
PVOP_VCALL0(load_tr_desc);
|
|
|
|
|
}
|
|
|
|
|
static inline void load_gdt(const struct Xgt_desc_struct *dtr)
|
|
|
|
|
{
|
|
|
|
|
PVOP_VCALL1(load_gdt, dtr);
|
|
|
|
|
}
|
|
|
|
|
static inline void load_idt(const struct Xgt_desc_struct *dtr)
|
|
|
|
|
{
|
|
|
|
|
PVOP_VCALL1(load_idt, dtr);
|
|
|
|
|
}
|
|
|
|
|
static inline void set_ldt(const void *addr, unsigned entries)
|
|
|
|
|
{
|
|
|
|
|
PVOP_VCALL2(set_ldt, addr, entries);
|
|
|
|
|
}
|
|
|
|
|
static inline void store_gdt(struct Xgt_desc_struct *dtr)
|
|
|
|
|
{
|
|
|
|
|
PVOP_VCALL1(store_gdt, dtr);
|
|
|
|
|
}
|
|
|
|
|
static inline void store_idt(struct Xgt_desc_struct *dtr)
|
|
|
|
|
{
|
|
|
|
|
PVOP_VCALL1(store_idt, dtr);
|
|
|
|
|
}
|
|
|
|
|
static inline unsigned long paravirt_store_tr(void)
|
|
|
|
|
{
|
|
|
|
|
return PVOP_CALL0(unsigned long, store_tr);
|
|
|
|
|
}
|
|
|
|
|
#define store_tr(tr) ((tr) = paravirt_store_tr())
|
|
|
|
|
static inline void load_TLS(struct thread_struct *t, unsigned cpu)
|
|
|
|
|
{
|
|
|
|
|
PVOP_VCALL2(load_tls, t, cpu);
|
|
|
|
|
}
|
|
|
|
|
static inline void write_ldt_entry(void *dt, int entry, u32 low, u32 high)
|
|
|
|
|
{
|
|
|
|
|
PVOP_VCALL4(write_ldt_entry, dt, entry, low, high);
|
|
|
|
|
}
|
|
|
|
|
static inline void write_gdt_entry(void *dt, int entry, u32 low, u32 high)
|
|
|
|
|
{
|
|
|
|
|
PVOP_VCALL4(write_gdt_entry, dt, entry, low, high);
|
|
|
|
|
}
|
|
|
|
|
static inline void write_idt_entry(void *dt, int entry, u32 low, u32 high)
|
|
|
|
|
{
|
|
|
|
|
PVOP_VCALL4(write_idt_entry, dt, entry, low, high);
|
|
|
|
|
}
|
|
|
|
|
static inline void set_iopl_mask(unsigned mask)
|
|
|
|
|
{
|
|
|
|
|
PVOP_VCALL1(set_iopl_mask, mask);
|
|
|
|
|
}
|
2007-05-02 17:27:13 +00:00
|
|
|
|
2006-12-07 01:14:07 +00:00
|
|
|
/* The paravirtualized I/O functions */
|
|
|
|
|
static inline void slow_down_io(void) {
|
|
|
|
|
paravirt_ops.io_delay();
|
|
|
|
|
#ifdef REALLY_SLOW_IO
|
|
|
|
|
paravirt_ops.io_delay();
|
|
|
|
|
paravirt_ops.io_delay();
|
|
|
|
|
paravirt_ops.io_delay();
|
|
|
|
|
#endif
|
|
|
|
|
}
|
|
|
|
|
|
2006-12-07 01:14:08 +00:00
|
|
|
#ifdef CONFIG_X86_LOCAL_APIC
|
|
|
|
|
/*
|
|
|
|
|
* Basic functions accessing APICs.
|
|
|
|
|
*/
|
|
|
|
|
static inline void apic_write(unsigned long reg, unsigned long v)
|
|
|
|
|
{
|
2007-05-02 17:27:14 +00:00
|
|
|
PVOP_VCALL2(apic_write, reg, v);
|
2006-12-07 01:14:08 +00:00
|
|
|
}
|
|
|
|
|
|
|
|
|
|
static inline void apic_write_atomic(unsigned long reg, unsigned long v)
|
|
|
|
|
{
|
2007-05-02 17:27:14 +00:00
|
|
|
PVOP_VCALL2(apic_write_atomic, reg, v);
|
2006-12-07 01:14:08 +00:00
|
|
|
}
|
|
|
|
|
|
|
|
|
|
static inline unsigned long apic_read(unsigned long reg)
|
|
|
|
|
{
|
2007-05-02 17:27:14 +00:00
|
|
|
return PVOP_CALL1(unsigned long, 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-05-02 17:27:14 +00:00
|
|
|
PVOP_VCALL0(setup_boot_clock);
|
2007-02-13 12:26:21 +00:00
|
|
|
}
|
|
|
|
|
|
|
|
|
|
static inline void setup_secondary_clock(void)
|
|
|
|
|
{
|
2007-05-02 17:27:14 +00:00
|
|
|
PVOP_VCALL0(setup_secondary_clock);
|
2007-02-13 12:26:21 +00:00
|
|
|
}
|
2006-12-07 01:14:08 +00:00
|
|
|
#endif
|
|
|
|
|
|
[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)
|
|
|
|
|
{
|
|
|
|
|
if (paravirt_ops.pagetable_setup_start)
|
|
|
|
|
(*paravirt_ops.pagetable_setup_start)(base);
|
|
|
|
|
}
|
|
|
|
|
|
|
|
|
|
static inline void paravirt_pagetable_setup_done(pgd_t *base)
|
|
|
|
|
{
|
|
|
|
|
if (paravirt_ops.pagetable_setup_done)
|
|
|
|
|
(*paravirt_ops.pagetable_setup_done)(base);
|
|
|
|
|
}
|
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-05-02 17:27:14 +00:00
|
|
|
PVOP_VCALL3(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-05-02 17:27:14 +00:00
|
|
|
PVOP_VCALL2(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-05-02 17:27:14 +00:00
|
|
|
PVOP_VCALL2(dup_mmap, oldmm, mm);
|
2007-05-02 17:27:14 +00:00
|
|
|
}
|
|
|
|
|
|
|
|
|
|
static inline void arch_exit_mmap(struct mm_struct *mm)
|
|
|
|
|
{
|
2007-05-02 17:27:14 +00:00
|
|
|
PVOP_VCALL1(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)
|
|
|
|
|
{
|
|
|
|
|
PVOP_VCALL0(flush_tlb_user);
|
|
|
|
|
}
|
|
|
|
|
static inline void __flush_tlb_global(void)
|
|
|
|
|
{
|
|
|
|
|
PVOP_VCALL0(flush_tlb_kernel);
|
|
|
|
|
}
|
|
|
|
|
static inline void __flush_tlb_single(unsigned long addr)
|
|
|
|
|
{
|
|
|
|
|
PVOP_VCALL1(flush_tlb_single, addr);
|
|
|
|
|
}
|
2006-12-07 01:14:08 +00:00
|
|
|
|
2007-05-02 17:27:14 +00:00
|
|
|
static inline void paravirt_map_pt_hook(int type, pte_t *va, u32 pfn)
|
|
|
|
|
{
|
|
|
|
|
PVOP_VCALL3(map_pt_hook, type, va, pfn);
|
|
|
|
|
}
|
2007-03-05 08:30:37 +00:00
|
|
|
|
2007-05-02 17:27:14 +00:00
|
|
|
static inline void paravirt_alloc_pt(unsigned pfn)
|
|
|
|
|
{
|
|
|
|
|
PVOP_VCALL1(alloc_pt, pfn);
|
|
|
|
|
}
|
|
|
|
|
static inline void paravirt_release_pt(unsigned pfn)
|
|
|
|
|
{
|
|
|
|
|
PVOP_VCALL1(release_pt, pfn);
|
|
|
|
|
}
|
2007-02-13 12:26:21 +00:00
|
|
|
|
2007-05-02 17:27:14 +00:00
|
|
|
static inline void paravirt_alloc_pd(unsigned pfn)
|
|
|
|
|
{
|
|
|
|
|
PVOP_VCALL1(alloc_pd, pfn);
|
|
|
|
|
}
|
2007-02-13 12:26:21 +00:00
|
|
|
|
2007-05-02 17:27:14 +00:00
|
|
|
static inline void paravirt_alloc_pd_clone(unsigned pfn, unsigned clonepfn,
|
|
|
|
|
unsigned start, unsigned count)
|
|
|
|
|
{
|
|
|
|
|
PVOP_VCALL4(alloc_pd_clone, pfn, clonepfn, start, count);
|
|
|
|
|
}
|
|
|
|
|
static inline void paravirt_release_pd(unsigned pfn)
|
2006-12-07 01:14:08 +00:00
|
|
|
{
|
2007-05-02 17:27:14 +00:00
|
|
|
PVOP_VCALL1(release_pd, pfn);
|
2006-12-07 01:14:08 +00:00
|
|
|
}
|
|
|
|
|
|
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-05-02 17:27:14 +00:00
|
|
|
PVOP_VCALL3(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-05-02 17:27:14 +00:00
|
|
|
PVOP_VCALL3(pte_update_defer, mm, addr, ptep);
|
2006-12-07 01:14:08 +00:00
|
|
|
}
|
|
|
|
|
|
2007-05-02 17:27:14 +00:00
|
|
|
#ifdef CONFIG_X86_PAE
|
|
|
|
|
static inline pte_t __pte(unsigned long long val)
|
2006-12-07 01:14:08 +00:00
|
|
|
{
|
2007-05-02 17:27:14 +00:00
|
|
|
unsigned long long ret = PVOP_CALL2(unsigned long long, make_pte,
|
|
|
|
|
val, val >> 32);
|
|
|
|
|
return (pte_t) { ret, ret >> 32 };
|
2006-12-07 01:14:08 +00:00
|
|
|
}
|
|
|
|
|
|
2007-05-02 17:27:14 +00:00
|
|
|
static inline pmd_t __pmd(unsigned long long val)
|
2006-12-07 01:14:08 +00:00
|
|
|
{
|
2007-05-02 17:27:14 +00:00
|
|
|
return (pmd_t) { PVOP_CALL2(unsigned long long, make_pmd, val, val >> 32) };
|
|
|
|
|
}
|
|
|
|
|
|
|
|
|
|
static inline pgd_t __pgd(unsigned long long val)
|
|
|
|
|
{
|
|
|
|
|
return (pgd_t) { PVOP_CALL2(unsigned long long, make_pgd, val, val >> 32) };
|
|
|
|
|
}
|
|
|
|
|
|
|
|
|
|
static inline unsigned long long pte_val(pte_t x)
|
|
|
|
|
{
|
|
|
|
|
return PVOP_CALL2(unsigned long long, pte_val, x.pte_low, x.pte_high);
|
|
|
|
|
}
|
|
|
|
|
|
|
|
|
|
static inline unsigned long long pmd_val(pmd_t x)
|
|
|
|
|
{
|
|
|
|
|
return PVOP_CALL2(unsigned long long, pmd_val, x.pmd, x.pmd >> 32);
|
|
|
|
|
}
|
|
|
|
|
|
|
|
|
|
static inline unsigned long long pgd_val(pgd_t x)
|
|
|
|
|
{
|
|
|
|
|
return PVOP_CALL2(unsigned long long, pgd_val, x.pgd, x.pgd >> 32);
|
|
|
|
|
}
|
|
|
|
|
|
|
|
|
|
static inline void set_pte(pte_t *ptep, pte_t pteval)
|
|
|
|
|
{
|
|
|
|
|
PVOP_VCALL3(set_pte, ptep, pteval.pte_low, pteval.pte_high);
|
|
|
|
|
}
|
|
|
|
|
|
|
|
|
|
static inline void set_pte_at(struct mm_struct *mm, unsigned long addr,
|
|
|
|
|
pte_t *ptep, pte_t pteval)
|
|
|
|
|
{
|
|
|
|
|
/* 5 arg words */
|
|
|
|
|
paravirt_ops.set_pte_at(mm, addr, ptep, pteval);
|
2006-12-07 01:14:08 +00:00
|
|
|
}
|
|
|
|
|
|
|
|
|
|
static inline void set_pte_atomic(pte_t *ptep, pte_t pteval)
|
|
|
|
|
{
|
2007-05-02 17:27:14 +00:00
|
|
|
PVOP_VCALL3(set_pte_atomic, ptep, pteval.pte_low, pteval.pte_high);
|
2006-12-07 01:14:08 +00:00
|
|
|
}
|
|
|
|
|
|
2007-05-02 17:27:14 +00:00
|
|
|
static inline void set_pte_present(struct mm_struct *mm, unsigned long addr,
|
|
|
|
|
pte_t *ptep, pte_t pte)
|
2006-12-07 01:14:08 +00:00
|
|
|
{
|
2007-05-02 17:27:14 +00:00
|
|
|
/* 5 arg words */
|
2006-12-07 01:14:08 +00:00
|
|
|
paravirt_ops.set_pte_present(mm, addr, ptep, pte);
|
|
|
|
|
}
|
|
|
|
|
|
2007-05-02 17:27:14 +00:00
|
|
|
static inline void set_pmd(pmd_t *pmdp, pmd_t pmdval)
|
|
|
|
|
{
|
|
|
|
|
PVOP_VCALL3(set_pmd, pmdp, pmdval.pmd, pmdval.pmd >> 32);
|
|
|
|
|
}
|
|
|
|
|
|
2006-12-07 01:14:08 +00:00
|
|
|
static inline void set_pud(pud_t *pudp, pud_t pudval)
|
|
|
|
|
{
|
2007-05-02 17:27:14 +00:00
|
|
|
PVOP_VCALL3(set_pud, pudp, pudval.pgd.pgd, pudval.pgd.pgd >> 32);
|
2006-12-07 01:14:08 +00:00
|
|
|
}
|
|
|
|
|
|
|
|
|
|
static inline void pte_clear(struct mm_struct *mm, unsigned long addr, pte_t *ptep)
|
|
|
|
|
{
|
2007-05-02 17:27:14 +00:00
|
|
|
PVOP_VCALL3(pte_clear, mm, addr, ptep);
|
2006-12-07 01:14:08 +00:00
|
|
|
}
|
|
|
|
|
|
|
|
|
|
static inline void pmd_clear(pmd_t *pmdp)
|
|
|
|
|
{
|
2007-05-02 17:27:14 +00:00
|
|
|
PVOP_VCALL1(pmd_clear, pmdp);
|
|
|
|
|
}
|
|
|
|
|
|
|
|
|
|
static inline pte_t raw_ptep_get_and_clear(pte_t *p)
|
|
|
|
|
{
|
|
|
|
|
unsigned long long val = PVOP_CALL1(unsigned long long, ptep_get_and_clear, p);
|
|
|
|
|
return (pte_t) { val, val >> 32 };
|
|
|
|
|
}
|
|
|
|
|
#else /* !CONFIG_X86_PAE */
|
|
|
|
|
static inline pte_t __pte(unsigned long val)
|
|
|
|
|
{
|
|
|
|
|
return (pte_t) { PVOP_CALL1(unsigned long, make_pte, val) };
|
2006-12-07 01:14:08 +00:00
|
|
|
}
|
2007-05-02 17:27:14 +00:00
|
|
|
|
|
|
|
|
static inline pgd_t __pgd(unsigned long val)
|
|
|
|
|
{
|
|
|
|
|
return (pgd_t) { PVOP_CALL1(unsigned long, make_pgd, val) };
|
|
|
|
|
}
|
|
|
|
|
|
|
|
|
|
static inline unsigned long pte_val(pte_t x)
|
|
|
|
|
{
|
|
|
|
|
return PVOP_CALL1(unsigned long, pte_val, x.pte_low);
|
|
|
|
|
}
|
|
|
|
|
|
|
|
|
|
static inline unsigned long pgd_val(pgd_t x)
|
|
|
|
|
{
|
|
|
|
|
return PVOP_CALL1(unsigned long, pgd_val, x.pgd);
|
|
|
|
|
}
|
|
|
|
|
|
|
|
|
|
static inline void set_pte(pte_t *ptep, pte_t pteval)
|
|
|
|
|
{
|
|
|
|
|
PVOP_VCALL2(set_pte, ptep, pteval.pte_low);
|
|
|
|
|
}
|
|
|
|
|
|
|
|
|
|
static inline void set_pte_at(struct mm_struct *mm, unsigned long addr,
|
|
|
|
|
pte_t *ptep, pte_t pteval)
|
|
|
|
|
{
|
|
|
|
|
PVOP_VCALL4(set_pte_at, mm, addr, ptep, pteval.pte_low);
|
|
|
|
|
}
|
|
|
|
|
|
|
|
|
|
static inline void set_pmd(pmd_t *pmdp, pmd_t pmdval)
|
|
|
|
|
{
|
|
|
|
|
PVOP_VCALL2(set_pmd, pmdp, pmdval.pud.pgd.pgd);
|
|
|
|
|
}
|
|
|
|
|
|
|
|
|
|
static inline pte_t raw_ptep_get_and_clear(pte_t *p)
|
|
|
|
|
{
|
|
|
|
|
return (pte_t) { PVOP_CALL1(unsigned long, ptep_get_and_clear, p) };
|
|
|
|
|
}
|
|
|
|
|
#endif /* CONFIG_X86_PAE */
|
2006-12-07 01:14:08 +00:00
|
|
|
|
2007-02-13 12:26:21 +00:00
|
|
|
/* Lazy mode for batching updates / context switch */
|
|
|
|
|
#define PARAVIRT_LAZY_NONE 0
|
|
|
|
|
#define PARAVIRT_LAZY_MMU 1
|
|
|
|
|
#define PARAVIRT_LAZY_CPU 2
|
2007-04-08 23:04:01 +00:00
|
|
|
#define PARAVIRT_LAZY_FLUSH 3
|
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)
|
|
|
|
|
{
|
|
|
|
|
PVOP_VCALL1(set_lazy_mode, PARAVIRT_LAZY_CPU);
|
|
|
|
|
}
|
|
|
|
|
|
|
|
|
|
static inline void arch_leave_lazy_cpu_mode(void)
|
|
|
|
|
{
|
|
|
|
|
PVOP_VCALL1(set_lazy_mode, PARAVIRT_LAZY_NONE);
|
|
|
|
|
}
|
|
|
|
|
|
|
|
|
|
static inline void arch_flush_lazy_cpu_mode(void)
|
|
|
|
|
{
|
|
|
|
|
PVOP_VCALL1(set_lazy_mode, PARAVIRT_LAZY_FLUSH);
|
|
|
|
|
}
|
|
|
|
|
|
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)
|
|
|
|
|
{
|
|
|
|
|
PVOP_VCALL1(set_lazy_mode, PARAVIRT_LAZY_MMU);
|
|
|
|
|
}
|
|
|
|
|
|
|
|
|
|
static inline void arch_leave_lazy_mmu_mode(void)
|
|
|
|
|
{
|
|
|
|
|
PVOP_VCALL1(set_lazy_mode, PARAVIRT_LAZY_NONE);
|
|
|
|
|
}
|
|
|
|
|
|
|
|
|
|
static inline void arch_flush_lazy_mmu_mode(void)
|
|
|
|
|
{
|
|
|
|
|
PVOP_VCALL1(set_lazy_mode, PARAVIRT_LAZY_FLUSH);
|
|
|
|
|
}
|
2007-02-13 12:26:21 +00:00
|
|
|
|
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[];
|
|
|
|
|
|
2006-12-07 01:14:08 +00:00
|
|
|
static inline unsigned long __raw_local_save_flags(void)
|
|
|
|
|
{
|
|
|
|
|
unsigned long f;
|
|
|
|
|
|
2007-05-02 17:27:14 +00:00
|
|
|
asm volatile(paravirt_alt("pushl %%ecx; pushl %%edx;"
|
|
|
|
|
PARAVIRT_CALL
|
|
|
|
|
"popl %%edx; popl %%ecx")
|
|
|
|
|
: "=a"(f)
|
|
|
|
|
: paravirt_type(save_fl),
|
2007-05-02 17:27:14 +00:00
|
|
|
paravirt_clobber(CLBR_EAX)
|
2007-05-02 17:27:14 +00:00
|
|
|
: "memory", "cc");
|
2006-12-07 01:14:08 +00:00
|
|
|
return f;
|
|
|
|
|
}
|
|
|
|
|
|
|
|
|
|
static inline void raw_local_irq_restore(unsigned long f)
|
|
|
|
|
{
|
2007-05-02 17:27:14 +00:00
|
|
|
asm volatile(paravirt_alt("pushl %%ecx; pushl %%edx;"
|
|
|
|
|
PARAVIRT_CALL
|
|
|
|
|
"popl %%edx; popl %%ecx")
|
|
|
|
|
: "=a"(f)
|
|
|
|
|
: "0"(f),
|
|
|
|
|
paravirt_type(restore_fl),
|
|
|
|
|
paravirt_clobber(CLBR_EAX)
|
|
|
|
|
: "memory", "cc");
|
2006-12-07 01:14:08 +00:00
|
|
|
}
|
|
|
|
|
|
|
|
|
|
static inline void raw_local_irq_disable(void)
|
|
|
|
|
{
|
2007-05-02 17:27:14 +00:00
|
|
|
asm volatile(paravirt_alt("pushl %%ecx; pushl %%edx;"
|
|
|
|
|
PARAVIRT_CALL
|
|
|
|
|
"popl %%edx; popl %%ecx")
|
|
|
|
|
:
|
|
|
|
|
: paravirt_type(irq_disable),
|
|
|
|
|
paravirt_clobber(CLBR_EAX)
|
|
|
|
|
: "memory", "eax", "cc");
|
2006-12-07 01:14:08 +00:00
|
|
|
}
|
|
|
|
|
|
|
|
|
|
static inline void raw_local_irq_enable(void)
|
|
|
|
|
{
|
2007-05-02 17:27:14 +00:00
|
|
|
asm volatile(paravirt_alt("pushl %%ecx; pushl %%edx;"
|
|
|
|
|
PARAVIRT_CALL
|
|
|
|
|
"popl %%edx; popl %%ecx")
|
|
|
|
|
:
|
|
|
|
|
: paravirt_type(irq_enable),
|
|
|
|
|
paravirt_clobber(CLBR_EAX)
|
|
|
|
|
: "memory", "eax", "cc");
|
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
|
|
|
#define CLI_STRING \
|
|
|
|
|
_paravirt_alt("pushl %%ecx; pushl %%edx;" \
|
|
|
|
|
"call *paravirt_ops+%c[paravirt_cli_type]*4;" \
|
|
|
|
|
"popl %%edx; popl %%ecx", \
|
|
|
|
|
"%c[paravirt_cli_type]", "%c[paravirt_clobber]")
|
|
|
|
|
|
|
|
|
|
#define STI_STRING \
|
|
|
|
|
_paravirt_alt("pushl %%ecx; pushl %%edx;" \
|
|
|
|
|
"call *paravirt_ops+%c[paravirt_sti_type]*4;" \
|
|
|
|
|
"popl %%edx; popl %%ecx", \
|
|
|
|
|
"%c[paravirt_sti_type]", "%c[paravirt_clobber]")
|
2006-12-07 01:14:08 +00:00
|
|
|
|
|
|
|
|
#define CLI_STI_CLOBBERS , "%eax"
|
2007-05-02 17:27:14 +00:00
|
|
|
#define CLI_STI_INPUT_ARGS \
|
2006-12-07 01:14:08 +00:00
|
|
|
, \
|
2007-05-02 17:27:14 +00:00
|
|
|
[paravirt_cli_type] "i" (PARAVIRT_PATCH(irq_disable)), \
|
|
|
|
|
[paravirt_sti_type] "i" (PARAVIRT_PATCH(irq_enable)), \
|
|
|
|
|
paravirt_clobber(CLBR_EAX)
|
|
|
|
|
|
|
|
|
|
#undef PARAVIRT_CALL
|
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__ */
|
|
|
|
|
|
2007-05-02 17:27:14 +00:00
|
|
|
#define PARA_PATCH(off) ((off) / 4)
|
|
|
|
|
|
|
|
|
|
#define PARA_SITE(ptype, clobbers, ops) \
|
2006-12-07 01:14:08 +00:00
|
|
|
771:; \
|
|
|
|
|
ops; \
|
|
|
|
|
772:; \
|
|
|
|
|
.pushsection .parainstructions,"a"; \
|
|
|
|
|
.long 771b; \
|
|
|
|
|
.byte ptype; \
|
|
|
|
|
.byte 772b-771b; \
|
|
|
|
|
.short clobbers; \
|
|
|
|
|
.popsection
|
|
|
|
|
|
2007-05-02 17:27:14 +00:00
|
|
|
#define INTERRUPT_RETURN \
|
2007-05-02 17:27:14 +00:00
|
|
|
PARA_SITE(PARA_PATCH(PARAVIRT_iret), CLBR_NONE, \
|
2007-05-02 17:27:14 +00:00
|
|
|
jmp *%cs:paravirt_ops+PARAVIRT_iret)
|
|
|
|
|
|
|
|
|
|
#define DISABLE_INTERRUPTS(clobbers) \
|
|
|
|
|
PARA_SITE(PARA_PATCH(PARAVIRT_irq_disable), clobbers, \
|
2007-05-02 17:27:14 +00:00
|
|
|
pushl %eax; pushl %ecx; pushl %edx; \
|
2007-05-02 17:27:14 +00:00
|
|
|
call *%cs:paravirt_ops+PARAVIRT_irq_disable; \
|
2007-05-02 17:27:14 +00:00
|
|
|
popl %edx; popl %ecx; popl %eax) \
|
2007-05-02 17:27:14 +00:00
|
|
|
|
|
|
|
|
#define ENABLE_INTERRUPTS(clobbers) \
|
|
|
|
|
PARA_SITE(PARA_PATCH(PARAVIRT_irq_enable), clobbers, \
|
2007-05-02 17:27:14 +00:00
|
|
|
pushl %eax; pushl %ecx; pushl %edx; \
|
2007-05-02 17:27:14 +00:00
|
|
|
call *%cs:paravirt_ops+PARAVIRT_irq_enable; \
|
2007-05-02 17:27:14 +00:00
|
|
|
popl %edx; popl %ecx; popl %eax)
|
2007-05-02 17:27:14 +00:00
|
|
|
|
|
|
|
|
#define ENABLE_INTERRUPTS_SYSEXIT \
|
2007-05-02 17:27:14 +00:00
|
|
|
PARA_SITE(PARA_PATCH(PARAVIRT_irq_enable_sysexit), CLBR_NONE, \
|
2007-05-02 17:27:14 +00:00
|
|
|
jmp *%cs:paravirt_ops+PARAVIRT_irq_enable_sysexit)
|
2006-12-07 01:14:08 +00:00
|
|
|
|
|
|
|
|
#define GET_CR0_INTO_EAX \
|
2007-05-02 17:27:14 +00:00
|
|
|
push %ecx; push %edx; \
|
|
|
|
|
call *paravirt_ops+PARAVIRT_read_cr0; \
|
|
|
|
|
pop %edx; pop %ecx
|
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 */
|