i386: page allocation hooks for VMI backend
Subsystems (2)
PATCH 3/10 i386: iOPL handling for paravirt guests
In reply to Andi KleenFrom: Zachary Amsden <[email protected]>
I found a clever way to make the extra IOPL switching invisible to non-paravirt compiles - since kernel_rpl is statically defined to be zero there, and only non-zero rpl kernel have a problem restoring IOPL, as popf does not restore IOPL flags unless run at CPL-0.
---
arch/i386/kernel/process.c | 9 +++++++++ 1 file changed, 9 insertions(+)
arch/i386/kernel/process.c +9 -0
@@ -670,6 +670,15 @@ struct task_struct fastcall * __switch_tload_TLS (next, cpu);/* +* Restore IOPL if needed. In normal use, the flags restore +* in the switch assembly will handle this. But if the kernel +* is running virtualized at a non-zero CPL, the popf will +* not restore flags, so it must be done in a separate step. +*/ +if (get_kernel_rpl () &&unlikely (prev->iopl != next->iopl)) +set_iopl_mask (next->iopl); + +/* * Now maybe handle debug registers and/or IO bitmaps */ if (unlikely((task_thread_info(next_p)->flags & _TIF_WORK_CTXSW)
PATCH 9/10 VMI: Vmi timer race
In reply to Andi KleenFrom: Zachary Amsden <[email protected]>
Because timer code moves around, and we might eventually move our init to a late_time_init hook, save and restore IRQs around this code because it is definitely not interrupt safe.
arch/i386/kernel/vmitime.c +5 -1
@@ -178,7 +178,9 @@ void __init vmi_time_init(void)void __init vmi_time_init (void ) {unsigned long long cycles_per_sec, cycles_per_msec; - +unsigned long flags; + +local_irq_save (flags);setup_irq (0 , &vmi_timer_irq);#ifdef CONFIG_X86_LOCAL_APIC set_intr_gate (LOCAL_TIMER_VECTOR , apic_vmi_timer_interrupt);
@@ -222,6 +224,8 @@ void __init vmi_time_init(void)VMI_ALARM_WIRED_IRQ0 |VMI_ALARM_IS_PERIODIC |VMI_CYCLES_AVAILABLE ,per_cpu (process_times_cycles_accounted_cpu,0 ) + cycles_per_alarm, cycles_per_alarm); + +local_irq_restore (flags); }#ifdef CONFIG_X86_LOCAL_APIC
PATCH 1/10 i386: page allocation hooks for VMI backend
From: Zachary Amsden <[email protected]>
The VMI backend uses explicit page type notification to track shadow page tables. The allocation of page table roots is especially tricky. We need to clone the root for non-PAE mode while it is protected under the pgd lock to correctly copy the shadow.
We don't need to allocate pgds in PAE mode, (PDPs in Intel terminology) as they only have 4 entries, and are cached entirely by the processor, which makes shadowing them rather simple.
For base page table level allocation, pmd_populate provides the exact hook point we need. Also, we need to allocate pages when splitting a large page, and we must release pages before returning the page to any free pool.
Despite being required with these slightly odd semantics for VMI, Xen also uses these hooks to determine the exact moment when page tables are created or released.
---
arch/i386/kernel/paravirt.c | 6 ++++++ arch/i386/mm/init.c | 4 ++++ arch/i386/mm/pageattr.c | 2 ++ arch/i386/mm/pgtable.c | 24 ++++++++++++++++++++---- include/asm-i386/paravirt.h | 14 ++++++++++++++ include/asm-i386/pgalloc.h | 30 ++++++++++++++++++++++++++---- 6 files changed, 72 insertions(+), 8 deletions(-)
arch/i386/kernel/paravirt.c +6 -0
@@ -550,6 +550,12 @@ struct paravirt_ops paravirt_ops = { .flush_tlb_kernel = native_flush_tlb_global, .flush_tlb_single = native_flush_tlb_single, + .alloc_pt = (void *)native_nop, + .alloc_pd = (void *)native_nop, + .alloc_pd_clone = (void *)native_nop, + .release_pt = (void *)native_nop, + .release_pd = (void *)native_nop, + .set_pte = native_set_pte, .set_pte_at = native_set_pte_at, .set_pmd = native_set_pmd,
arch/i386/mm/init.c +4 -0
@@ -62,6 +62,7 @@ static pmd_t * __init one_md_table_init(#ifdef CONFIG_X86_PAE pmd_table = (pmd_t *)alloc_bootmem_low_pages (PAGE_SIZE ); +paravirt_alloc_pd (__pa (pmd_table) >>PAGE_SHIFT );set_pgd (pgd,__pgd (__pa (pmd_table) | _PAGE_PRESENT)); pud =pud_offset (pgd,0 );if (pmd_table !=pmd_offset (pud,0 ))
@@ -82,6 +83,7 @@ static pte_t * __init one_page_table_ini {if (pmd_none (*pmd)) {pte_t *page_table = (pte_t *)alloc_bootmem_low_pages (PAGE_SIZE ); +paravirt_alloc_pt (__pa (page_table) >>PAGE_SHIFT );set_pmd (pmd,__pmd (__pa (page_table) | _PAGE_TABLE));if (page_table !=pte_offset_kernel (pmd,0 ))BUG ();
@@ -345,6 +347,8 @@ static void __init pagetable_init (void)/* Init entries of the first-level page table to the zero page */ for (i =0 ; i <PTRS_PER_PGD ; i++)set_pgd (pgd_base + i,__pgd (__pa (empty_zero_page) | _PAGE_PRESENT)); +#else +paravirt_alloc_pd (__pa (swapper_pg_dir) >>PAGE_SHIFT );#endif /* Enable PSE if available */
arch/i386/mm/pageattr.c +2 -0
@@ -60,6 +60,7 @@ static struct page *split_large_page(uns address =__pa (address); addr = address &LARGE_PAGE_MASK ; pbase = (pte_t *)page_address (base); +paravirt_alloc_pt (page_to_pfn (base));for (i =0 ; i <PTRS_PER_PTE ; i++, addr +=PAGE_SIZE ) {set_pte (&pbase[i],pfn_pte (addr >>PAGE_SHIFT , addr == address ? prot : ref_prot));
@@ -172,6 +173,7 @@ __change_page_attr(struct page *page, pgif (!PageReserved (kpte_page)) {if (cpu_has_pse && (page_private (kpte_page) ==0 )) {ClearPagePrivate (kpte_page); +paravirt_release_pt (page_to_pfn (kpte_page));list_add (&kpte_page->lru, &df_list);revert_page (kpte_page, address); }
arch/i386/mm/pgtable.c +20 -4
@@ -248,9 +248,15 @@ void pgd_ctor(void *pgd, struct kmem_cacclone_pgd_range ((pgd_t *)pgd +USER_PTRS_PER_PGD , swapper_pg_dir +USER_PTRS_PER_PGD ,KERNEL_PGD_PTRS ); +if (PTRS_PER_PMD >1 )return ; +/* must happen under lock */ +paravirt_alloc_pd_clone (__pa (pgd) >>PAGE_SHIFT , +__pa (swapper_pg_dir) >>PAGE_SHIFT , +USER_PTRS_PER_PGD ,PTRS_PER_PGD -USER_PTRS_PER_PGD ); +pgd_list_add (pgd);spin_unlock_irqrestore (&pgd_lock, flags); }
@@ -260,6 +266,7 @@ void pgd_dtor(void *pgd, struct kmem_cac {unsigned long flags;/* can be called from interrupt context */ +paravirt_release_pd (__pa (pgd) >>PAGE_SHIFT );spin_lock_irqsave (&pgd_lock, flags);pgd_list_del (pgd);spin_unlock_irqrestore (&pgd_lock, flags);
@@ -277,13 +284,18 @@ pgd_t *pgd_alloc(struct mm_struct *mm)pmd_t *pmd =kmem_cache_alloc (pmd_cache,GFP_KERNEL );if (!pmd) goto out_oom; +paravirt_alloc_pd (__pa (pmd) >>PAGE_SHIFT );set_pgd (&pgd[i],__pgd (1 +__pa (pmd))); }return pgd; out_oom: -for (i--; i >=0 ; i--) -kmem_cache_free (pmd_cache, (void *)__va (pgd_val (pgd[i])-1 )); +for (i--; i >=0 ; i--) { +pgd_t pgdent = pgd[i]; +void * pmd = (void *)__va (pgd_val (pgdent)-1 ); +paravirt_release_pd (__pa (pmd) >>PAGE_SHIFT ); +kmem_cache_free (pmd_cache, pmd); + }kmem_cache_free (pgd_cache, pgd);return NULL ; }
@@ -294,8 +306,12 @@ void pgd_free(pgd_t *pgd)/* in the PAE case user pgd entries are overwritten before usage */ if (PTRS_PER_PMD >1 ) -for (i =0 ; i <USER_PTRS_PER_PGD ; ++i) -kmem_cache_free (pmd_cache, (void *)__va (pgd_val (pgd[i])-1 )); +for (i =0 ; i <USER_PTRS_PER_PGD ; ++i) { +pgd_t pgdent = pgd[i]; +void * pmd = (void *)__va (pgd_val (pgdent)-1 ); +paravirt_release_pd (__pa (pmd) >>PAGE_SHIFT ); +kmem_cache_free (pmd_cache, pmd); + }/* in the non-PAE case, free_pgtables() clears user pgd entries */ kmem_cache_free (pgd_cache, pgd); }
include/asm-i386/paravirt.h +14 -0
@@ -127,6 +127,12 @@ struct paravirt_ops void (fastcall *flush_tlb_kernel)(void); void (fastcall *flush_tlb_single)(u32 addr); + void (fastcall *alloc_pt)(u32 pfn); + void (fastcall *alloc_pd)(u32 pfn); + void (fastcall *alloc_pd_clone)(u32 pfn, u32 clonepfn, u32 start, u32 count); + void (fastcall *release_pt)(u32 pfn); + void (fastcall *release_pd)(u32 pfn); + void (fastcall *set_pte)(pte_t *ptep, pte_t pteval); void (fastcall *set_pte_at)(struct mm_struct *mm, u32 addr, pte_t *ptep, pte_t pteval); void (fastcall *set_pmd)(pmd_t *pmdp, pmd_t pmdval);
@@ -320,6 +326,14 @@ static inline unsigned long apic_read(un#define __flush_tlb_global () paravirt_ops.flush_tlb_kernel()#define __flush_tlb_single (addr) paravirt_ops.flush_tlb_single(addr) +#define paravirt_alloc_pt (pfn) paravirt_ops.alloc_pt(pfn) +#define paravirt_release_pt (pfn) paravirt_ops.release_pt(pfn) + +#define paravirt_alloc_pd (pfn) paravirt_ops.alloc_pd(pfn) +#define paravirt_alloc_pd_clone (pfn, clonepfn, start, count) \ + paravirt_ops.alloc_pd_clone(pfn, clonepfn, start, count) +#define paravirt_release_pd (pfn) paravirt_ops.release_pd(pfn) +static inline void set_pte (pte_t *ptep,pte_t pteval) { paravirt_ops.set_pte (ptep, pteval);
include/asm-i386/pgalloc.h +26 -4
@@ -5,13 +5,31 @@#include <linux/threads.h> #include <linux/mm.h> /* for struct page */ -#define pmd_populate_kernel (mm, pmd, pte) \ - set_pmd(pmd, __pmd(_PAGE_TABLE + __pa(pte))) +#ifdef CONFIG_PARAVIRT +#include <asm/paravirt.h> +#else +#define paravirt_alloc_pt (pfn) do { } while (0) +#define paravirt_alloc_pd (pfn) do { } while (0) +#define paravirt_alloc_pd (pfn) do { } while (0) +#define paravirt_alloc_pd_clone (pfn, clonepfn, start, count) do { } while (0) +#define paravirt_release_pt (pfn) do { } while (0) +#define paravirt_release_pd (pfn) do { } while (0) +#endif + +#define pmd_populate_kernel (mm, pmd, pte) \ +do { \ + paravirt_alloc_pt(__pa(pte) >> PAGE_SHIFT); \ + set_pmd(pmd, __pmd(_PAGE_TABLE + __pa(pte))); \ +} while (0)#define pmd_populate (mm, pmd, pte) \ +do { \ + paravirt_alloc_pt(page_to_pfn(pte)); \ set_pmd(pmd, __pmd(_PAGE_TABLE + \ ((unsigned long long)page_to_pfn(pte) << \ - (unsigned long long) PAGE_SHIFT))) + (unsigned long long) PAGE_SHIFT))); \ +} while (0) +/* * Allocate and free page tables. */
@@ -32,7 +50,11 @@ static inline void pte_free(struct page } -#define __pte_free_tlb (tlb,pte) tlb_remove_page((tlb),(pte)) +#define __pte_free_tlb (tlb,pte) \ +do { \ + paravirt_release_pt(page_to_pfn(pte)); \ + tlb_remove_page((tlb),(pte)); \ +} while (0)#ifdef CONFIG_X86_PAE /*
PATCH 4/10 i386: sMP boot hook for paravirt
From: Zachary Amsden <[email protected]>
Add VMI SMP boot hook. We emulate a regular boot sequence and use the same APIC IPI initiation, we just poke magic values to load into the CPU state when the startup IPI is received, rather than having to jump through a real mode trampoline.
This is all that was needed to get SMP to work.
---
arch/i386/kernel/paravirt.c | 2 ++ arch/i386/kernel/smpboot.c | 7 +++++++ include/asm-i386/paravirt.h | 9 +++++++++ include/asm-i386/smp.h | 5 +++++ 4 files changed, 23 insertions(+)
arch/i386/kernel/paravirt.c +2 -0
@@ -572,6 +572,8 @@ struct paravirt_ops paravirt_ops = { .irq_enable_sysexit = native_irq_enable_sysexit, .iret = native_iret, + + .startup_ipi_hook = (void *)native_nop, };/*
arch/i386/kernel/smpboot.c +7 -0
@@ -834,6 +834,13 @@ wakeup_secondary_cpu(int phys_apicid, un num_starts =0 ;/* +* Paravirt / VMI wants a startup IPI hook here to set up the +* target processor state. +*/ +startup_ipi_hook (phys_apicid, (unsigned long ) start_secondary, + (unsigned long ) stack_start.esp); + +/* * Run STARTUP IPI loop. */ Dprintk ("#startup loops: %d.\n" , num_starts);
include/asm-i386/paravirt.h +9 -0
@@ -151,6 +151,8 @@ struct paravirt_ops/* These two are jmp to, not actually called. */ void (fastcall *irq_enable_sysexit)(void); void (fastcall *iret)(void); + + void (fastcall *startup_ipi_hook)(int phys_apicid, unsigned long start_eip, unsigned long start_esp); };/* Mark a paravirt probe function. */
@@ -323,6 +325,13 @@ static inline unsigned long apic_read(un }#endif +#ifdef CONFIG_SMP +static inline void startup_ipi_hook (int phys_apicid,unsigned long start_eip, +unsigned long start_esp) +{ +return paravirt_ops.startup_ipi_hook (phys_apicid, start_eip, start_esp); +} +#endif #define __flush_tlb () paravirt_ops.flush_tlb_user()#define __flush_tlb_global () paravirt_ops.flush_tlb_kernel()
include/asm-i386/smp.h +5 -0
@@ -52,6 +52,11 @@ extern void cpu_exit_clear(void);extern void cpu_uninit (void );#endif +#ifndef CONFIG_PARAVIRT +#define startup_ipi_hook (phys_apicid, start_eip, start_esp) \ +do { } while (0) +#endif +/* * This function is needed by all SMP systems. It must _always_ be valid * from the initial startup. We map APIC_BASE very early in page_setup(),
PATCH 6/10 i386: vMI timer patches
In reply to Andi KleenFrom: Zachary Amsden <[email protected]>
VMI timer code. It works by taking over the local APIC clock when APIC is configured, which requires a couple hooks into the APIC code. The backend timer code could be commonized into the timer infrastructure, but there are some pieces missing (stolen time, in particular), and the exact semantics of when to do accounting for NO_IDLE need to be shared between different hypervisors as well. So for now, VMI timer is a separate module.
[Adrian Bunk: cleanups]
Subject: VMI timer patches
---
arch/i386/Kconfig | 9 arch/i386/kernel/Makefile | 2 arch/i386/kernel/apic.c | 2 arch/i386/kernel/entry.S | 5 arch/i386/kernel/paravirt.c | 2 arch/i386/kernel/smpboot.c | 4 arch/i386/kernel/time.c | 4 arch/i386/kernel/tsc.c | 4 arch/i386/kernel/vmi.c | 45 ++++ arch/i386/kernel/vmitime.c | 495 ++++++++++++++++++++++++++++++++++++++++++++ include/asm-i386/apic.h | 2 include/asm-i386/paravirt.h | 12 + include/asm-i386/time.h | 1 include/asm-i386/timer.h | 2 include/asm-i386/vmi_time.h | 103 +++++++++ 15 files changed, 687 insertions(+), 5 deletions(-)
arch/i386/Kconfig +9 -0
@@ -1268,3 +1268,12 @@ config X86_TRAMPOLINE config KTIME_SCALAR bool default y + +config NO_IDLE_HZ + bool + depends on PARAVIRT + default y + help + Switches the regular HZ timer off when the system is going idle. + This helps a hypervisor detect that the Linux system is idle, + reducing the overhead of idle systems.
arch/i386/kernel/Makefile +1 -1
@@ -40,7 +40,7 @@ obj-$(CONFIG_EARLY_PRINTK) += early_prin obj-$(CONFIG_HPET_TIMER) += hpet.o obj-$(CONFIG_K8_NB) += k8.o -obj-$(CONFIG_VMI) += vmi.o +obj-$(CONFIG_VMI) += vmi.o vmitime.o # Make sure this is linked after any other paravirt_ops structs: see head.S obj-$(CONFIG_PARAVIRT) += paravirt.o
arch/i386/kernel/apic.c +1 -1
@@ -1395,7 +1395,7 @@ int __init APIC_init_uniprocessor (void)if (!skip_ioapic_setup && nr_ioapics)setup_IO_APIC ();#endif -setup_boot_APIC_clock (); +setup_boot_clock ();return 0 ; }
arch/i386/kernel/entry.S +5 -0
@@ -626,6 +626,11 @@ ENTRY(name) \ /* The include is where all of the SMP etc. interrupts come from */ #include "entry_arch.h" +/* This alternate entry is needed because we hijack the apic LVTT */ +#if defined(CONFIG_VMI) && defined(CONFIG_X86_LOCAL_APIC) +BUILD_INTERRUPT(apic_vmi_timer_interrupt,LOCAL_TIMER_VECTOR) +#endif + KPROBE_ENTRY(page_fault) RING0_EC_FRAME pushl $do_page_fault
arch/i386/kernel/paravirt.c +2 -0
@@ -544,6 +544,8 @@ struct paravirt_ops paravirt_ops = { .apic_write = native_apic_write, .apic_write_atomic = native_apic_write_atomic, .apic_read = native_apic_read, + .setup_boot_clock = setup_boot_APIC_clock, + .setup_secondary_clock = setup_secondary_APIC_clock, #endif .set_lazy_mode = (void *)native_nop,
arch/i386/kernel/smpboot.c +2 -2
@@ -553,7 +553,7 @@ static void __cpuinit start_secondary(vosmp_callin ();while (!cpu_isset (smp_processor_id (), smp_commenced_mask))rep_nop (); -setup_secondary_APIC_clock (); +setup_secondary_clock ();if (nmi_watchdog ==NMI_IO_APIC ) {disable_8259A_irq (0 );enable_NMI_through_LVT0 (NULL );
@@ -1330,7 +1330,7 @@ static void __init smp_boot_cpus(unsignesmpboot_setup_io_apic (); -setup_boot_APIC_clock (); +setup_boot_clock ();/* * Synchronize the TSC with the AP
arch/i386/kernel/time.c +3 -1
@@ -232,6 +232,7 @@ EXPORT_SYMBOL(get_cmos_time);static void sync_cmos_clock (unsigned long dummy); static DEFINE_TIMER(sync_cmos_timer, sync_cmos_clock, 0, 0); +int no_sync_cmos_clock;static void sync_cmos_clock (unsigned long dummy) {
@@ -275,7 +276,8 @@ static void sync_cmos_clock(unsigned lonvoid notify_arch_cmos_timer (void ) { -mod_timer (&sync_cmos_timer, jiffies +1 ); +if (!no_sync_cmos_clock) +mod_timer (&sync_cmos_timer, jiffies +1 ); }static long clock_cmos_diff;
arch/i386/kernel/tsc.c +4 -0
@@ -23,6 +23,7 @@* an extra value to store the TSC freq */ unsigned int tsc_khz; +unsigned long long (*custom_sched_clock)(void );int tsc_disable;
@@ -107,6 +108,9 @@ unsigned long long sched_clock(void) {unsigned long long this_offset; +if (unlikely (custom_sched_clock)) +return (*custom_sched_clock)(); +/* * in the NUMA case we dont use the TSC as they are not * synchronized across all CPUs.
arch/i386/kernel/vmi.c +45 -0
76 lines not on this page · raw message
arch/i386/kernel/vmitime.c new file +495 -0
495 lines not on this page · raw message
include/asm-i386/apic.h +2 -0
@@ -43,6 +43,8 @@ extern void generic_apic_probe(void);#define apic_write native_apic_write#define apic_write_atomic native_apic_write_atomic#define apic_read native_apic_read +#define setup_boot_clock setup_boot_APIC_clock +#define setup_secondary_clock setup_secondary_APIC_clock#endif static __inline fastcall void native_apic_write(unsigned long reg,
include/asm-i386/paravirt.h +12 -0
@@ -121,6 +121,8 @@ struct paravirt_ops void (fastcall *apic_write)(unsigned long reg, unsigned long v); void (fastcall *apic_write_atomic)(unsigned long reg, unsigned long v); unsigned long (fastcall *apic_read)(unsigned long reg); +void (*setup_boot_clock)(void ); +void (*setup_secondary_clock)(void );#endif void (fastcall *flush_tlb_user)(void);
@@ -323,6 +325,16 @@ static inline unsigned long apic_read(un {return paravirt_ops.apic_read (reg); } + +static inline void setup_boot_clock (void ) +{ + paravirt_ops.setup_boot_clock (); +} + +static inline void setup_secondary_clock (void ) +{ + paravirt_ops.setup_secondary_clock (); +}#endif #ifdef CONFIG_SMP
include/asm-i386/time.h +1 -0
@@ -30,6 +30,7 @@ static inline int native_set_wallclock(u#ifdef CONFIG_PARAVIRT #include <asm/paravirt.h> +extern unsigned long long native_sched_clock (void );#else /* !CONFIG_PARAVIRT */ #define get_wallclock () native_get_wallclock()
include/asm-i386/timer.h +2 -0
@@ -9,6 +9,8 @@ void setup_pit_timer(void);extern int pit_latch_buggy;extern int timer_ack;extern int no_timer_check; +extern unsigned long long (*custom_sched_clock)(void ); +extern int no_sync_cmos_clock;extern int recalibrate_cpu_khz (void );#endif
include/asm-i386/vmi_time.h new file +103 -0
103 lines not on this page · raw message
PATCH 8/10 VMI: Kprobe rpl fix
In reply to Andi KleenFrom: Zachary Amsden <[email protected]>
Kprobes bugfix for paravirt compatibility - RPL on the CS when inserting BPs must match running kernel.
arch/i386/kernel/kprobes.c +1 -1
@@ -408,7 +408,7 @@ fastcall void *__kprobes trampoline_handspin_lock_irqsave (&kretprobe_lock, flags); head =kretprobe_inst_table_head (current);/* fixup registers */ - regs->xcs = __KERNEL_CS; + regs->xcs = __KERNEL_CS |get_kernel_rpl (); regs->eip = trampoline_address; regs->orig_eax =0xffffffff ;
PATCH 5/10 i386: vMI backend for paravirt-ops
In reply to Andi KleenFrom: Zachary Amsden <[email protected]>
Fairly straightforward implementation of VMI backend for paravirt-ops.
[Adrian Bunk: some cleanups]
---
arch/i386/Kconfig | 9 arch/i386/kernel/Makefile | 2 arch/i386/kernel/head.S | 2 arch/i386/kernel/io_apic.c | 2 arch/i386/kernel/setup.c | 9 arch/i386/kernel/smpboot.c | 4 arch/i386/kernel/vmi.c | 904 +++++++++++++++++++++++++++++++++++++++++++++ arch/i386/mm/pgtable.c | 2 include/asm-i386/timer.h | 1 include/asm-i386/vmi.h | 262 +++++++++++++ 10 files changed, 1195 insertions(+), 2 deletions(-)
arch/i386/Kconfig +9 -0
@@ -199,6 +199,15 @@ config PARAVIRT However, when run without a hypervisor the kernel is theoretically slower. If in doubt, say N. +config VMI + bool "VMI Paravirt-ops support" + depends on PARAVIRT + default y + help + VMI provides a paravirtualized interface to multiple hypervisors + include VMware ESX server and Xen by connecting to a ROM module + provided by the hypervisor. + config ACPI_SRAT bool default y
arch/i386/kernel/Makefile +2 -0
@@ -40,6 +40,8 @@ obj-$(CONFIG_EARLY_PRINTK) += early_prin obj-$(CONFIG_HPET_TIMER) += hpet.o obj-$(CONFIG_K8_NB) += k8.o +obj-$(CONFIG_VMI) += vmi.o + # Make sure this is linked after any other paravirt_ops structs: see head.S obj-$(CONFIG_PARAVIRT) += paravirt.o
arch/i386/kernel/head.S +1 -1
@@ -360,7 +360,7 @@ check_x87: * cpu_gdt_table and boot_pda; for secondary CPUs, these will be * that CPU's GDT and PDA. */ -setup_pda: +ENTRY(setup_pda) /* get the PDA pointer */ movl start_pda, %eax
arch/i386/kernel/io_apic.c +1 -1
@@ -1920,7 +1920,7 @@ static void __init setup_ioapic_ids_fromstatic void __init setup_ioapic_ids_from_mpc (void ) { }#endif -static int no_timer_check__initdata ; +int no_timer_check__initdata ;static int __init notimercheck (char *s) {
arch/i386/kernel/setup.c +9 -0
@@ -60,6 +60,7 @@#include <asm/io_apic.h> #include <asm/ist.h> #include <asm/io.h> +#include <asm/vmi.h> #include <setup_arch.h> #include <bios_ebda.h>
@@ -581,6 +582,14 @@ void __init setup_arch(char **cmdline_p) max_low_pfn =setup_memory (); +#ifdef CONFIG_VMI +/* +* Must be after max_low_pfn is determined, and before kernel +* pagetables are setup. +*/ +vmi_init (); +#endif +/* * NOTE: before this point _nobody_ is allowed to allocate * any memory using the bootmem allocator. Although the
arch/i386/kernel/smpboot.c +4 -0
@@ -62,6 +62,7 @@#include <mach_apic.h> #include <mach_wakecpu.h> #include <smpboot_hooks.h> +#include <asm/vmi.h> /* Set if we find a B stepping CPU */ static int __devinitdata smp_b_stepping;
@@ -544,6 +545,9 @@ static void __cpuinit start_secondary(vo* booting is too fragile that we want to limit the * things done here to the most necessary things. */ +#ifdef CONFIG_VMI +vmi_bringup (); +#endif secondary_cpu_init ();preempt_disable ();smp_callin ();
arch/i386/kernel/vmi.c new file +904 -0
904 lines not on this page · raw message
arch/i386/mm/pgtable.c +2 -0
@@ -171,6 +171,8 @@ void __set_fixmap (enum fixed_addressesvoid reserve_top_address (unsigned long reserve) {BUG_ON (fixmaps >0 ); +printk (KERN_INFO "Reserving virtual address space above 0x%08x\n" , + (int )-reserve);#ifdef CONFIG_COMPAT_VDSO BUG_ON (reserve !=0 );#else
include/asm-i386/timer.h +1 -0
@@ -8,6 +8,7 @@ void setup_pit_timer(void);/* Modifiers for buggy PIT handling */ extern int pit_latch_buggy;extern int timer_ack; +extern int no_timer_check;extern int recalibrate_cpu_khz (void );#endif
include/asm-i386/vmi.h new file +262 -0
262 lines not on this page · raw message
PATCH 7/10 VMI: Profile pc badness
In reply to Andi KleenFrom: Zachary Amsden <[email protected]>Profile_pc was broken when using paravirtualization because the assumption the kernel was running at CPL 0 was violated, causing bad logic to read a random value off the stack.
The only way to be in kernel lock functions is to be in kernel code, so validate that assumption explicitly by checking the CS value. We don't want to be fooled by BIOS / APM segments and try to read those stacks, so only match KERNEL_CS.
I moved some stuff in segment.h to make it prettier.
arch/i386/kernel/time.c +4 -6
@@ -131,15 +131,13 @@ unsigned long profile_pc(struct pt_regsunsigned long pc =instruction_pointer (regs);#ifdef CONFIG_SMP -if (!user_mode_vm (regs) &&in_lock_functions (pc)) { +if (!v8086_mode (regs) &&SEGMENT_IS_KERNEL_CODE (regs->xcs) && +in_lock_functions (pc)) {#ifdef CONFIG_FRAME_POINTER return *(unsigned long *)(regs->ebp +4 );#else -unsigned long *sp; -if ((regs->xcs &3 ) ==0 ) - sp = (unsigned long *)®s->esp; -else - sp = (unsigned long *)regs->esp; +unsigned long *sp = (unsigned long *)®s->esp; +/* Return address is either directly at stack pointer or above a saved eflags. Eflags has bits 22-31 zero, kernel addresses don't. */
include/asm-i386/ptrace.h +4 -0
@@ -49,6 +49,10 @@ static inline int user_mode_vm(struct pt {return ((regs->xcs &SEGMENT_RPL_MASK ) | (regs->eflags &VM_MASK )) >=USER_RPL ; } +static inline int v8086_mode (struct pt_regs *regs) +{ +return (regs->eflags &VM_MASK ); +}#define instruction_pointer (regs) ((regs)->eip)#define regs_return_value (regs) ((regs)->eax)
include/asm-i386/segment.h +13 -6
@@ -83,13 +83,7 @@* The GDT has 32 entries */ #define GDT_ENTRIES 32 -#define GDT_SIZE (GDT_ENTRIES * 8) - -/* Matches __KERNEL_CS and __USER_CS (they must be 2 entries apart) */ -#define SEGMENT_IS_FLAT_CODE (x) (((x) & 0xec) == GDT_ENTRY_KERNEL_CS * 8) -/* Matches PNP_CS32 and PNP_CS16 (they must be consecutive) */ -#define SEGMENT_IS_PNP_CODE (x) (((x) & 0xf4) == GDT_ENTRY_PNPBIOS_BASE * 8)/* Simple and small GDT entries for booting only */
@@ -134,4 +128,17 @@#ifndef CONFIG_PARAVIRT #define get_kernel_rpl () 0#endif +/* +* Matching rules for certain types of segments. +*/ + +/* Matches only __KERNEL_CS, ignoring PnP / USER / APM segments */ +#define SEGMENT_IS_KERNEL_CODE (x) (((x) & 0xfc) == GDT_ENTRY_KERNEL_CS * 8) + +/* Matches __KERNEL_CS and __USER_CS (they must be 2 entries apart) */ +#define SEGMENT_IS_FLAT_CODE (x) (((x) & 0xec) == GDT_ENTRY_KERNEL_CS * 8) + +/* Matches PNP_CS32 and PNP_CS16 (they must be consecutive) */ +#define SEGMENT_IS_PNP_CODE (x) (((x) & 0xf4) == GDT_ENTRY_PNPBIOS_BASE * 8) +#endif
PATCH 10/10 VMI: Paravirt debug defaults off
In reply to Andi KleenFrom: Zachary Amsden <[email protected]>
Deliberate register clobber around performance critical inline code is great for testing, bad to leave on by default. Many people ship with DEBUG_KERNEL turned on, so stop making DEBUG_PARAVIRT default on.
arch/i386/Kconfig.debug +1 -1
@@ -89,7 +89,7 @@ config DOUBLEFAULT config DEBUG_PARAVIRT bool "Enable some paravirtualization debugging" - default y + default n depends on PARAVIRT && DEBUG_KERNEL help Currently deliberately clobbers regs which are allowed to be
PATCH 2/10 i386: paravirt CPU hypercall batching mode
In reply to Andi KleenFrom: Zachary Amsden <[email protected]>
The VMI ROM has a mode where hypercalls can be queued and batched. This turns out to be a significant win during context switch, but must be done at a specific point before side effects to CPU state are visible to subsequent instructions. This is similar to the MMU batching hooks already provided. The same hooks could be used by the Xen backend to implement a context switch multicall.
To explain a bit more about lazy modes in the paravirt patches, basically, the idea is that only one of lazy CPU or MMU mode can be active at any given time.
Lazy MMU mode is similar to this lazy CPU mode, and allows for batching of
multiple PTE updates (say, inside a remap loop), but to avoid keeping some kind of state machine about when to flush cpu or mmu updates, we just allow one or the other to be active. Although there is no real reason a more comprehensive scheme could not be implemented, there is also no demonstrated need for this extra complexity.
---
arch/i386/kernel/paravirt.c | 1 + arch/i386/kernel/process.c | 25 +++++++++++++++++-------- include/asm-generic/pgtable.h | 13 +++++++++++++ include/asm-i386/paravirt.h | 15 +++++++++++++++ kernel/sched.c | 7 +++++++ 5 files changed, 53 insertions(+), 8 deletions(-)
arch/i386/kernel/paravirt.c +1 -0
@@ -545,6 +545,7 @@ struct paravirt_ops paravirt_ops = { .apic_write_atomic = native_apic_write_atomic, .apic_read = native_apic_read, #endif + .set_lazy_mode = (void *)native_nop, .flush_tlb_user = native_flush_tlb, .flush_tlb_kernel = native_flush_tlb_global,
arch/i386/kernel/process.c +17 -8
@@ -670,14 +670,6 @@ struct task_struct fastcall * __switch_tload_TLS (next, cpu);/* -* Restore %gs if needed (which is common) -*/ -if (prev->gs | next->gs) -loadsegment (gs, next->gs); - -write_pda (pcurrent, next_p); - -/* * Now maybe handle debug registers and/or IO bitmaps */ if (unlikely((task_thread_info(next_p)->flags & _TIF_WORK_CTXSW)
@@ -686,6 +678,15 @@ struct task_struct fastcall * __switch_tdisable_tsc (prev_p, next_p); +/* +* Leave lazy mode, flushing any hypercalls made here. +* This must be done before restoring TLS segments so +* the GDT and LDT are properly updated, and must be +* done before math_state_restore, so the TS bit is up +* to date. +*/ +arch_leave_lazy_cpu_mode (); +/* If the task has used fpu the last 5 timeslices, just do a full * restore of the math state immediately to avoid the trap; the * chances of needing FPU soon are obviously high now
@@ -693,6 +694,14 @@ struct task_struct fastcall * __switch_tif (next_p->fpu_counter >5 )math_state_restore (); +/* +* Restore %gs if needed (which is common) +*/ +if (prev->gs | next->gs) +loadsegment (gs, next->gs); + +write_pda (pcurrent, next_p); +return prev_p; }
include/asm-generic/pgtable.h +13 -0
@@ -183,6 +183,19 @@ static inline void ptep_set_wrprotect(st#endif /* +* A facility to provide batching of the reload of page tables with the +* actual context switch code for paravirtualized guests. By convention, +* only one of the lazy modes (CPU, MMU) should be active at any given +* time, entry should never be nested, and entry and exits should always +* be paired. This is for sanity of maintaining and reasoning about the +* kernel code. +*/ +#ifndef __HAVE_ARCH_ENTER_LAZY_CPU_MODE +#define arch_enter_lazy_cpu_mode () do {} while (0) +#define arch_leave_lazy_cpu_mode () do {} while (0) +#endif + +/* * When walking page tables, get the address of the next boundary, * or the end address of the range if that comes earlier. Although no * vma end wraps to 0, rounded up __boundary may wrap to 0 throughout.
include/asm-i386/paravirt.h +15 -0
@@ -146,6 +146,8 @@ struct paravirt_ops void (fastcall *pmd_clear)(pmd_t *pmdp);#endif + void (fastcall *set_lazy_mode)(int mode); +/* These two are jmp to, not actually called. */ void (fastcall *irq_enable_sysexit)(void); void (fastcall *iret)(void);
@@ -386,6 +388,19 @@ static inline void pmd_clear(pmd_t *pmdp }#endif +/* Lazy mode for batching updates / context switch */ +#define PARAVIRT_LAZY_NONE 0 +#define PARAVIRT_LAZY_MMU 1 +#define PARAVIRT_LAZY_CPU 2 + +#define __HAVE_ARCH_ENTER_LAZY_CPU_MODE +#define arch_enter_lazy_cpu_mode () paravirt_ops.set_lazy_mode(PARAVIRT_LAZY_CPU) +#define arch_leave_lazy_cpu_mode () paravirt_ops.set_lazy_mode(PARAVIRT_LAZY_NONE) + +#define __HAVE_ARCH_ENTER_LAZY_MMU_MODE +#define arch_enter_lazy_mmu_mode () paravirt_ops.set_lazy_mode(PARAVIRT_LAZY_MMU) +#define arch_leave_lazy_mmu_mode () paravirt_ops.set_lazy_mode(PARAVIRT_LAZY_NONE) +/* These all sit in the .parainstructions section to tell us what to patch. */ struct paravirt_patch {u8 *instr;/* original instructions */
kernel/sched.c +7 -0
@@ -1843,6 +1843,13 @@ context_switch(struct rq *rq, struct tasstruct mm_struct *mm = next->mm;struct mm_struct *oldmm = prev->active_mm; +/* +* For paravirt, this is coupled with an exit in switch_to to +* combine the page table reload and the switch backend into +* one hypercall. +*/ +arch_enter_lazy_cpu_mode (); +if (!mm) { next->active_mm = oldmm;atomic_inc (&oldmm->mm_count);