forked from luck/tmp_suning_uos_patched
0195c00244
-----BEGIN PGP SIGNATURE----- Version: GnuPG v1.4.12 (GNU/Linux) iQIVAwUAT3NKzROxKuMESys7AQKElw/+JyDxJSlj+g+nymkx8IVVuU8CsEwNLgRk 8KEnRfLhGtkXFLSJYWO6jzGo16F8Uqli1PdMFte/wagSv0285/HZaKlkkBVHdJ/m u40oSjgT013bBh6MQ0Oaf8pFezFUiQB5zPOA9QGaLVGDLXCmgqUgd7exaD5wRIwB ZmyItjZeAVnDfk1R+ZiNYytHAi8A5wSB+eFDCIQYgyulA1Igd1UnRtx+dRKbvc/m rWQ6KWbZHIdvP1ksd8wHHkrlUD2pEeJ8glJLsZUhMm/5oMf/8RmOCvmo8rvE/qwl eDQ1h4cGYlfjobxXZMHqAN9m7Jg2bI946HZjdb7/7oCeO6VW3FwPZ/Ic75p+wp45 HXJTItufERYk6QxShiOKvA+QexnYwY0IT5oRP4DrhdVB/X9cl2MoaZHC+RbYLQy+ /5VNZKi38iK4F9AbFamS7kd0i5QszA/ZzEzKZ6VMuOp3W/fagpn4ZJT1LIA3m4A9 Q0cj24mqeyCfjysu0TMbPtaN+Yjeu1o1OFRvM8XffbZsp5bNzuTDEvviJ2NXw4vK 4qUHulhYSEWcu9YgAZXvEWDEM78FXCkg2v/CrZXH5tyc95kUkMPcgG+QZBB5wElR FaOKpiC/BuNIGEf02IZQ4nfDxE90QwnDeoYeV+FvNj9UEOopJ5z5bMPoTHxm4cCD NypQthI85pc= =G9mT -----END PGP SIGNATURE----- Merge tag 'split-asm_system_h-for-linus-20120328' of git://git.kernel.org/pub/scm/linux/kernel/git/dhowells/linux-asm_system Pull "Disintegrate and delete asm/system.h" from David Howells: "Here are a bunch of patches to disintegrate asm/system.h into a set of separate bits to relieve the problem of circular inclusion dependencies. I've built all the working defconfigs from all the arches that I can and made sure that they don't break. The reason for these patches is that I recently encountered a circular dependency problem that came about when I produced some patches to optimise get_order() by rewriting it to use ilog2(). This uses bitops - and on the SH arch asm/bitops.h drags in asm-generic/get_order.h by a circuituous route involving asm/system.h. The main difficulty seems to be asm/system.h. It holds a number of low level bits with no/few dependencies that are commonly used (eg. memory barriers) and a number of bits with more dependencies that aren't used in many places (eg. switch_to()). These patches break asm/system.h up into the following core pieces: (1) asm/barrier.h Move memory barriers here. This already done for MIPS and Alpha. (2) asm/switch_to.h Move switch_to() and related stuff here. (3) asm/exec.h Move arch_align_stack() here. Other process execution related bits could perhaps go here from asm/processor.h. (4) asm/cmpxchg.h Move xchg() and cmpxchg() here as they're full word atomic ops and frequently used by atomic_xchg() and atomic_cmpxchg(). (5) asm/bug.h Move die() and related bits. (6) asm/auxvec.h Move AT_VECTOR_SIZE_ARCH here. Other arch headers are created as needed on a per-arch basis." Fixed up some conflicts from other header file cleanups and moving code around that has happened in the meantime, so David's testing is somewhat weakened by that. We'll find out anything that got broken and fix it.. * tag 'split-asm_system_h-for-linus-20120328' of git://git.kernel.org/pub/scm/linux/kernel/git/dhowells/linux-asm_system: (38 commits) Delete all instances of asm/system.h Remove all #inclusions of asm/system.h Add #includes needed to permit the removal of asm/system.h Move all declarations of free_initmem() to linux/mm.h Disintegrate asm/system.h for OpenRISC Split arch_align_stack() out from asm-generic/system.h Split the switch_to() wrapper out of asm-generic/system.h Move the asm-generic/system.h xchg() implementation to asm-generic/cmpxchg.h Create asm-generic/barrier.h Make asm-generic/cmpxchg.h #include asm-generic/cmpxchg-local.h Disintegrate asm/system.h for Xtensa Disintegrate asm/system.h for Unicore32 [based on ver #3, changed by gxt] Disintegrate asm/system.h for Tile Disintegrate asm/system.h for Sparc Disintegrate asm/system.h for SH Disintegrate asm/system.h for Score Disintegrate asm/system.h for S390 Disintegrate asm/system.h for PowerPC Disintegrate asm/system.h for PA-RISC Disintegrate asm/system.h for MN10300 ...
491 lines
12 KiB
C
491 lines
12 KiB
C
/* Paravirtualization interfaces
|
|
Copyright (C) 2006 Rusty Russell IBM Corporation
|
|
|
|
This program is free software; you can redistribute it and/or modify
|
|
it under the terms of the GNU General Public License as published by
|
|
the Free Software Foundation; either version 2 of the License, or
|
|
(at your option) any later version.
|
|
|
|
This program is distributed in the hope that it will be useful,
|
|
but WITHOUT ANY WARRANTY; without even the implied warranty of
|
|
MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
|
|
GNU General Public License for more details.
|
|
|
|
You should have received a copy of the GNU General Public License
|
|
along with this program; if not, write to the Free Software
|
|
Foundation, Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301 USA
|
|
|
|
2007 - x86_64 support added by Glauber de Oliveira Costa, Red Hat Inc
|
|
*/
|
|
|
|
#include <linux/errno.h>
|
|
#include <linux/module.h>
|
|
#include <linux/efi.h>
|
|
#include <linux/bcd.h>
|
|
#include <linux/highmem.h>
|
|
|
|
#include <asm/bug.h>
|
|
#include <asm/paravirt.h>
|
|
#include <asm/debugreg.h>
|
|
#include <asm/desc.h>
|
|
#include <asm/setup.h>
|
|
#include <asm/pgtable.h>
|
|
#include <asm/time.h>
|
|
#include <asm/pgalloc.h>
|
|
#include <asm/irq.h>
|
|
#include <asm/delay.h>
|
|
#include <asm/fixmap.h>
|
|
#include <asm/apic.h>
|
|
#include <asm/tlbflush.h>
|
|
#include <asm/timer.h>
|
|
#include <asm/special_insns.h>
|
|
|
|
/* nop stub */
|
|
void _paravirt_nop(void)
|
|
{
|
|
}
|
|
|
|
/* identity function, which can be inlined */
|
|
u32 _paravirt_ident_32(u32 x)
|
|
{
|
|
return x;
|
|
}
|
|
|
|
u64 _paravirt_ident_64(u64 x)
|
|
{
|
|
return x;
|
|
}
|
|
|
|
void __init default_banner(void)
|
|
{
|
|
printk(KERN_INFO "Booting paravirtualized kernel on %s\n",
|
|
pv_info.name);
|
|
}
|
|
|
|
/* 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 ":")
|
|
|
|
/* Undefined instruction for dealing with missing ops pointers. */
|
|
static const unsigned char ud2a[] = { 0x0f, 0x0b };
|
|
|
|
unsigned paravirt_patch_nop(void)
|
|
{
|
|
return 0;
|
|
}
|
|
|
|
unsigned paravirt_patch_ignore(unsigned len)
|
|
{
|
|
return len;
|
|
}
|
|
|
|
struct branch {
|
|
unsigned char opcode;
|
|
u32 delta;
|
|
} __attribute__((packed));
|
|
|
|
unsigned paravirt_patch_call(void *insnbuf,
|
|
const void *target, u16 tgt_clobbers,
|
|
unsigned long addr, u16 site_clobbers,
|
|
unsigned len)
|
|
{
|
|
struct branch *b = insnbuf;
|
|
unsigned long delta = (unsigned long)target - (addr+5);
|
|
|
|
if (tgt_clobbers & ~site_clobbers)
|
|
return len; /* target would clobber too much for this site */
|
|
if (len < 5)
|
|
return len; /* call too long for patch site */
|
|
|
|
b->opcode = 0xe8; /* call */
|
|
b->delta = delta;
|
|
BUILD_BUG_ON(sizeof(*b) != 5);
|
|
|
|
return 5;
|
|
}
|
|
|
|
unsigned paravirt_patch_jmp(void *insnbuf, const void *target,
|
|
unsigned long addr, unsigned len)
|
|
{
|
|
struct branch *b = insnbuf;
|
|
unsigned long delta = (unsigned long)target - (addr+5);
|
|
|
|
if (len < 5)
|
|
return len; /* call too long for patch site */
|
|
|
|
b->opcode = 0xe9; /* jmp */
|
|
b->delta = delta;
|
|
|
|
return 5;
|
|
}
|
|
|
|
/* Neat trick to map patch type back to the call within the
|
|
* corresponding structure. */
|
|
static void *get_call_destination(u8 type)
|
|
{
|
|
struct paravirt_patch_template tmpl = {
|
|
.pv_init_ops = pv_init_ops,
|
|
.pv_time_ops = pv_time_ops,
|
|
.pv_cpu_ops = pv_cpu_ops,
|
|
.pv_irq_ops = pv_irq_ops,
|
|
.pv_apic_ops = pv_apic_ops,
|
|
.pv_mmu_ops = pv_mmu_ops,
|
|
#ifdef CONFIG_PARAVIRT_SPINLOCKS
|
|
.pv_lock_ops = pv_lock_ops,
|
|
#endif
|
|
};
|
|
return *((void **)&tmpl + type);
|
|
}
|
|
|
|
unsigned paravirt_patch_default(u8 type, u16 clobbers, void *insnbuf,
|
|
unsigned long addr, unsigned len)
|
|
{
|
|
void *opfunc = get_call_destination(type);
|
|
unsigned ret;
|
|
|
|
if (opfunc == NULL)
|
|
/* If there's no function, patch it with a ud2a (BUG) */
|
|
ret = paravirt_patch_insns(insnbuf, len, ud2a, ud2a+sizeof(ud2a));
|
|
else if (opfunc == _paravirt_nop)
|
|
/* If the operation is a nop, then nop the callsite */
|
|
ret = paravirt_patch_nop();
|
|
|
|
/* identity functions just return their single argument */
|
|
else if (opfunc == _paravirt_ident_32)
|
|
ret = paravirt_patch_ident_32(insnbuf, len);
|
|
else if (opfunc == _paravirt_ident_64)
|
|
ret = paravirt_patch_ident_64(insnbuf, len);
|
|
|
|
else if (type == PARAVIRT_PATCH(pv_cpu_ops.iret) ||
|
|
type == PARAVIRT_PATCH(pv_cpu_ops.irq_enable_sysexit) ||
|
|
type == PARAVIRT_PATCH(pv_cpu_ops.usergs_sysret32) ||
|
|
type == PARAVIRT_PATCH(pv_cpu_ops.usergs_sysret64))
|
|
/* If operation requires a jmp, then jmp */
|
|
ret = paravirt_patch_jmp(insnbuf, opfunc, addr, len);
|
|
else
|
|
/* Otherwise call the function; assume target could
|
|
clobber any caller-save reg */
|
|
ret = paravirt_patch_call(insnbuf, opfunc, CLBR_ANY,
|
|
addr, clobbers, len);
|
|
|
|
return ret;
|
|
}
|
|
|
|
unsigned paravirt_patch_insns(void *insnbuf, unsigned len,
|
|
const char *start, const char *end)
|
|
{
|
|
unsigned insn_len = end - start;
|
|
|
|
if (insn_len > len || start == NULL)
|
|
insn_len = len;
|
|
else
|
|
memcpy(insnbuf, start, insn_len);
|
|
|
|
return insn_len;
|
|
}
|
|
|
|
static void native_flush_tlb(void)
|
|
{
|
|
__native_flush_tlb();
|
|
}
|
|
|
|
/*
|
|
* Global pages have to be flushed a bit differently. Not a real
|
|
* performance problem because this does not happen often.
|
|
*/
|
|
static void native_flush_tlb_global(void)
|
|
{
|
|
__native_flush_tlb_global();
|
|
}
|
|
|
|
static void native_flush_tlb_single(unsigned long addr)
|
|
{
|
|
__native_flush_tlb_single(addr);
|
|
}
|
|
|
|
struct static_key paravirt_steal_enabled;
|
|
struct static_key paravirt_steal_rq_enabled;
|
|
|
|
static u64 native_steal_clock(int cpu)
|
|
{
|
|
return 0;
|
|
}
|
|
|
|
/* These are in entry.S */
|
|
extern void native_iret(void);
|
|
extern void native_irq_enable_sysexit(void);
|
|
extern void native_usergs_sysret32(void);
|
|
extern void native_usergs_sysret64(void);
|
|
|
|
static struct resource reserve_ioports = {
|
|
.start = 0,
|
|
.end = IO_SPACE_LIMIT,
|
|
.name = "paravirt-ioport",
|
|
.flags = IORESOURCE_IO | IORESOURCE_BUSY,
|
|
};
|
|
|
|
/*
|
|
* Reserve the whole legacy IO space to prevent any legacy drivers
|
|
* from wasting time probing for their hardware. This is a fairly
|
|
* brute-force approach to disabling all non-virtual drivers.
|
|
*
|
|
* Note that this must be called very early to have any effect.
|
|
*/
|
|
int paravirt_disable_iospace(void)
|
|
{
|
|
return request_resource(&ioport_resource, &reserve_ioports);
|
|
}
|
|
|
|
static DEFINE_PER_CPU(enum paravirt_lazy_mode, paravirt_lazy_mode) = PARAVIRT_LAZY_NONE;
|
|
|
|
static inline void enter_lazy(enum paravirt_lazy_mode mode)
|
|
{
|
|
BUG_ON(percpu_read(paravirt_lazy_mode) != PARAVIRT_LAZY_NONE);
|
|
|
|
percpu_write(paravirt_lazy_mode, mode);
|
|
}
|
|
|
|
static void leave_lazy(enum paravirt_lazy_mode mode)
|
|
{
|
|
BUG_ON(percpu_read(paravirt_lazy_mode) != mode);
|
|
|
|
percpu_write(paravirt_lazy_mode, PARAVIRT_LAZY_NONE);
|
|
}
|
|
|
|
void paravirt_enter_lazy_mmu(void)
|
|
{
|
|
enter_lazy(PARAVIRT_LAZY_MMU);
|
|
}
|
|
|
|
void paravirt_leave_lazy_mmu(void)
|
|
{
|
|
leave_lazy(PARAVIRT_LAZY_MMU);
|
|
}
|
|
|
|
void paravirt_start_context_switch(struct task_struct *prev)
|
|
{
|
|
BUG_ON(preemptible());
|
|
|
|
if (percpu_read(paravirt_lazy_mode) == PARAVIRT_LAZY_MMU) {
|
|
arch_leave_lazy_mmu_mode();
|
|
set_ti_thread_flag(task_thread_info(prev), TIF_LAZY_MMU_UPDATES);
|
|
}
|
|
enter_lazy(PARAVIRT_LAZY_CPU);
|
|
}
|
|
|
|
void paravirt_end_context_switch(struct task_struct *next)
|
|
{
|
|
BUG_ON(preemptible());
|
|
|
|
leave_lazy(PARAVIRT_LAZY_CPU);
|
|
|
|
if (test_and_clear_ti_thread_flag(task_thread_info(next), TIF_LAZY_MMU_UPDATES))
|
|
arch_enter_lazy_mmu_mode();
|
|
}
|
|
|
|
enum paravirt_lazy_mode paravirt_get_lazy_mode(void)
|
|
{
|
|
if (in_interrupt())
|
|
return PARAVIRT_LAZY_NONE;
|
|
|
|
return percpu_read(paravirt_lazy_mode);
|
|
}
|
|
|
|
void arch_flush_lazy_mmu_mode(void)
|
|
{
|
|
preempt_disable();
|
|
|
|
if (paravirt_get_lazy_mode() == PARAVIRT_LAZY_MMU) {
|
|
arch_leave_lazy_mmu_mode();
|
|
arch_enter_lazy_mmu_mode();
|
|
}
|
|
|
|
preempt_enable();
|
|
}
|
|
|
|
struct pv_info pv_info = {
|
|
.name = "bare hardware",
|
|
.paravirt_enabled = 0,
|
|
.kernel_rpl = 0,
|
|
.shared_kernel_pmd = 1, /* Only used when CONFIG_X86_PAE is set */
|
|
|
|
#ifdef CONFIG_X86_64
|
|
.extra_user_64bit_cs = __USER_CS,
|
|
#endif
|
|
};
|
|
|
|
struct pv_init_ops pv_init_ops = {
|
|
.patch = native_patch,
|
|
};
|
|
|
|
struct pv_time_ops pv_time_ops = {
|
|
.sched_clock = native_sched_clock,
|
|
.steal_clock = native_steal_clock,
|
|
};
|
|
|
|
struct pv_irq_ops pv_irq_ops = {
|
|
.save_fl = __PV_IS_CALLEE_SAVE(native_save_fl),
|
|
.restore_fl = __PV_IS_CALLEE_SAVE(native_restore_fl),
|
|
.irq_disable = __PV_IS_CALLEE_SAVE(native_irq_disable),
|
|
.irq_enable = __PV_IS_CALLEE_SAVE(native_irq_enable),
|
|
.safe_halt = native_safe_halt,
|
|
.halt = native_halt,
|
|
#ifdef CONFIG_X86_64
|
|
.adjust_exception_frame = paravirt_nop,
|
|
#endif
|
|
};
|
|
|
|
struct pv_cpu_ops pv_cpu_ops = {
|
|
.cpuid = native_cpuid,
|
|
.get_debugreg = native_get_debugreg,
|
|
.set_debugreg = native_set_debugreg,
|
|
.clts = native_clts,
|
|
.read_cr0 = native_read_cr0,
|
|
.write_cr0 = native_write_cr0,
|
|
.read_cr4 = native_read_cr4,
|
|
.read_cr4_safe = native_read_cr4_safe,
|
|
.write_cr4 = native_write_cr4,
|
|
#ifdef CONFIG_X86_64
|
|
.read_cr8 = native_read_cr8,
|
|
.write_cr8 = native_write_cr8,
|
|
#endif
|
|
.wbinvd = native_wbinvd,
|
|
.read_msr = native_read_msr_safe,
|
|
.rdmsr_regs = native_rdmsr_safe_regs,
|
|
.write_msr = native_write_msr_safe,
|
|
.wrmsr_regs = native_wrmsr_safe_regs,
|
|
.read_tsc = native_read_tsc,
|
|
.read_pmc = native_read_pmc,
|
|
.read_tscp = native_read_tscp,
|
|
.load_tr_desc = native_load_tr_desc,
|
|
.set_ldt = native_set_ldt,
|
|
.load_gdt = native_load_gdt,
|
|
.load_idt = native_load_idt,
|
|
.store_gdt = native_store_gdt,
|
|
.store_idt = native_store_idt,
|
|
.store_tr = native_store_tr,
|
|
.load_tls = native_load_tls,
|
|
#ifdef CONFIG_X86_64
|
|
.load_gs_index = native_load_gs_index,
|
|
#endif
|
|
.write_ldt_entry = native_write_ldt_entry,
|
|
.write_gdt_entry = native_write_gdt_entry,
|
|
.write_idt_entry = native_write_idt_entry,
|
|
|
|
.alloc_ldt = paravirt_nop,
|
|
.free_ldt = paravirt_nop,
|
|
|
|
.load_sp0 = native_load_sp0,
|
|
|
|
#if defined(CONFIG_X86_32) || defined(CONFIG_IA32_EMULATION)
|
|
.irq_enable_sysexit = native_irq_enable_sysexit,
|
|
#endif
|
|
#ifdef CONFIG_X86_64
|
|
#ifdef CONFIG_IA32_EMULATION
|
|
.usergs_sysret32 = native_usergs_sysret32,
|
|
#endif
|
|
.usergs_sysret64 = native_usergs_sysret64,
|
|
#endif
|
|
.iret = native_iret,
|
|
.swapgs = native_swapgs,
|
|
|
|
.set_iopl_mask = native_set_iopl_mask,
|
|
.io_delay = native_io_delay,
|
|
|
|
.start_context_switch = paravirt_nop,
|
|
.end_context_switch = paravirt_nop,
|
|
};
|
|
|
|
struct pv_apic_ops pv_apic_ops = {
|
|
#ifdef CONFIG_X86_LOCAL_APIC
|
|
.startup_ipi_hook = paravirt_nop,
|
|
#endif
|
|
};
|
|
|
|
#if defined(CONFIG_X86_32) && !defined(CONFIG_X86_PAE)
|
|
/* 32-bit pagetable entries */
|
|
#define PTE_IDENT __PV_IS_CALLEE_SAVE(_paravirt_ident_32)
|
|
#else
|
|
/* 64-bit pagetable entries */
|
|
#define PTE_IDENT __PV_IS_CALLEE_SAVE(_paravirt_ident_64)
|
|
#endif
|
|
|
|
struct pv_mmu_ops pv_mmu_ops = {
|
|
|
|
.read_cr2 = native_read_cr2,
|
|
.write_cr2 = native_write_cr2,
|
|
.read_cr3 = native_read_cr3,
|
|
.write_cr3 = native_write_cr3,
|
|
|
|
.flush_tlb_user = native_flush_tlb,
|
|
.flush_tlb_kernel = native_flush_tlb_global,
|
|
.flush_tlb_single = native_flush_tlb_single,
|
|
.flush_tlb_others = native_flush_tlb_others,
|
|
|
|
.pgd_alloc = __paravirt_pgd_alloc,
|
|
.pgd_free = paravirt_nop,
|
|
|
|
.alloc_pte = paravirt_nop,
|
|
.alloc_pmd = paravirt_nop,
|
|
.alloc_pud = paravirt_nop,
|
|
.release_pte = paravirt_nop,
|
|
.release_pmd = paravirt_nop,
|
|
.release_pud = paravirt_nop,
|
|
|
|
.set_pte = native_set_pte,
|
|
.set_pte_at = native_set_pte_at,
|
|
.set_pmd = native_set_pmd,
|
|
.set_pmd_at = native_set_pmd_at,
|
|
.pte_update = paravirt_nop,
|
|
.pte_update_defer = paravirt_nop,
|
|
.pmd_update = paravirt_nop,
|
|
.pmd_update_defer = paravirt_nop,
|
|
|
|
.ptep_modify_prot_start = __ptep_modify_prot_start,
|
|
.ptep_modify_prot_commit = __ptep_modify_prot_commit,
|
|
|
|
#if PAGETABLE_LEVELS >= 3
|
|
#ifdef CONFIG_X86_PAE
|
|
.set_pte_atomic = native_set_pte_atomic,
|
|
.pte_clear = native_pte_clear,
|
|
.pmd_clear = native_pmd_clear,
|
|
#endif
|
|
.set_pud = native_set_pud,
|
|
|
|
.pmd_val = PTE_IDENT,
|
|
.make_pmd = PTE_IDENT,
|
|
|
|
#if PAGETABLE_LEVELS == 4
|
|
.pud_val = PTE_IDENT,
|
|
.make_pud = PTE_IDENT,
|
|
|
|
.set_pgd = native_set_pgd,
|
|
#endif
|
|
#endif /* PAGETABLE_LEVELS >= 3 */
|
|
|
|
.pte_val = PTE_IDENT,
|
|
.pgd_val = PTE_IDENT,
|
|
|
|
.make_pte = PTE_IDENT,
|
|
.make_pgd = PTE_IDENT,
|
|
|
|
.dup_mmap = paravirt_nop,
|
|
.exit_mmap = paravirt_nop,
|
|
.activate_mm = paravirt_nop,
|
|
|
|
.lazy_mode = {
|
|
.enter = paravirt_nop,
|
|
.leave = paravirt_nop,
|
|
},
|
|
|
|
.set_fixmap = native_set_fixmap,
|
|
};
|
|
|
|
EXPORT_SYMBOL_GPL(pv_time_ops);
|
|
EXPORT_SYMBOL (pv_cpu_ops);
|
|
EXPORT_SYMBOL (pv_mmu_ops);
|
|
EXPORT_SYMBOL_GPL(pv_apic_ops);
|
|
EXPORT_SYMBOL_GPL(pv_info);
|
|
EXPORT_SYMBOL (pv_irq_ops);
|