lguest and virtio patches
Subsystems (3)
The following changes since commit 5d80f8e5a9dc9c9a94d4aeaa567e219a808b8a4a:
Linus Torvalds (1):
Merge git://git.kernel.org/.../davem/net-2.6
are available in the git repository at:
ssh://master.kernel.org/pub/scm/linux/kernel/git/rusty/linux-2.6-lguest-and-virtio.git master
Matias Zabaljauregui (2):
lguest: use KVM hypercalls
lguest: use bool instead of int
Roel Kluin (1):
virtio: fix BAD_RING, START_US and END_USE macros
Rusty Russell (5):
virtio: more neatening of virtio_ring macros.
lguest: fix spurious BUG_ON() on invalid guest stack.
lguest: wire up pte_update/pte_update_defer
lguest: avoid accidental recycling of pgdir pages
lguest: barrier me harder
Documentation/lguest/lguest.c | 7 +++ arch/x86/include/asm/lguest_hcall.h | 25 ++------- arch/x86/lguest/boot.c | 94 +++++++++++++++++++++++---------- arch/x86/lguest/i386_head.S | 4 +- drivers/lguest/core.c | 4 +- drivers/lguest/hypercalls.c | 3 + drivers/lguest/interrupts_and_traps.c | 28 +++++----- drivers/lguest/lg.h | 9 ++-- drivers/lguest/lguest_device.c | 4 +- drivers/lguest/page_tables.c | 38 ++++++++++---- drivers/lguest/segments.c | 2 +- drivers/lguest/x86/core.c | 62 +++++++++++++++++++++- drivers/virtio/virtio_ring.c | 22 +++++--- 13 files changed, 210 insertions(+), 92 deletions(-)
commit ca98502ca12192f7f1aec0239734458901c4fdd6
Author: Roel Kluin <[email protected]> Date: Thu Jan 22 16:42:57 2009 +0100
virtio: fix BAD_RING, START_US and END_USE macros
Impact: cleanup
fix BAD_RING, START_US and END_USE macros
When these macros aren't called with a variable named vq as first argument, this would result in a build failure.
drivers/virtio/virtio_ring.c | 16 ++++++++-------- 1 files changed, 8 insertions(+), 8 deletions(-)
commit d8cac090dbf12b5651609776b18446cd984a4d74
Author: Rusty Russell <[email protected]> Date: Sat Mar 28 23:39:16 2009 -0600
virtio: more neatening of virtio_ring macros.
Impact: cleanup
Roel Kluin drew attention to these macros with his patch: here I neaten them a little further:
1) Add a comment on what START_USE and END_USE are checking,
2) Brackets around _vq in BAD_RING,
3) Neaten formatting for START_USE so it's less than 80 cols.
drivers/virtio/virtio_ring.c | 12 +++++++++--- 1 files changed, 9 insertions(+), 3 deletions(-)
commit ffa4ae2fe9c68fe35d0dbf29a05af5aff392122b
Author: Rusty Russell <[email protected]> Date: Sat Mar 28 23:39:16 2009 -0600
lguest: fix spurious BUG_ON() on invalid guest stack.
Impact: fix crash on misbehaving guest
gpte_addr() contains a BUG_ON(), insisting that the present flag is set. We need to return before we call it if that isn't the case.
drivers/lguest/page_tables.c | 4 +++- 1 files changed, 3 insertions(+), 1 deletions(-)
commit bb32d14a9e3efd1578e8ad53286de71a992bb4db
Author: Rusty Russell <[email protected]> Date: Sat Mar 28 23:39:16 2009 -0600
lguest: wire up pte_update/pte_update_defer
Impact: intermittent guest segv/crash fix
I've been seeing random guest bad address crashes and segmentation faults:
bisect led to 4f98a2fee8 (vmscan: split LRU lists into anon & file sets), but that's a red herring.
It turns out that lguest never hooked up the pte_update/pte_update_defer calls, so our ptes were not always in sync. After the vmscan commit, the bug became reproducible; now a fsck in a 64MB guest causes reproducible pagetable corruption.
arch/x86/lguest/boot.c | 10 +++++++++- 1 files changed, 9 insertions(+), 1 deletions(-)
commit 754b83efa91a021395c7df119ce53aeb32cce11d
Author: Rusty Russell <[email protected]> Date: Sat Mar 28 23:39:17 2009 -0600
lguest: avoid accidental recycling of pgdir pages
Impact: potential bugfix
In theory, the kernel could reuse the same page as pgdir for a new process while the hypervisor keeps it cached. This would have undesirable results.
arch/x86/include/asm/lguest_hcall.h | 1 + arch/x86/lguest/boot.c | 8 ++++++++ drivers/lguest/hypercalls.c | 3 +++ drivers/lguest/lg.h | 1 + drivers/lguest/page_tables.c | 16 ++++++++++++++++ 5 files changed, 29 insertions(+), 0 deletions(-)
commit b6757ad1aeeefbe439596dc09f23a4fee16c9079
Author: Matias Zabaljauregui <[email protected]> Date: Sat Mar 14 13:37:52 2009 -0200
lguest: use KVM hypercalls
Impact: cleanup
This patch allow us to use KVM hypercalls
arch/x86/include/asm/lguest_hcall.h | 24 ++-------- arch/x86/lguest/boot.c | 80 ++++++++++++++++++++------------ arch/x86/lguest/i386_head.S | 4 +- drivers/lguest/interrupts_and_traps.c | 7 ++- drivers/lguest/lguest_device.c | 4 +- drivers/lguest/x86/core.c | 62 +++++++++++++++++++++++++- 6 files changed, 123 insertions(+), 58 deletions(-)
commit f8f81b891f9e2bb0e149c6bfb6b153ea72f5d8ab
Author: Matias Zabaljauregui <[email protected]> Date: Wed Mar 18 13:38:35 2009 -0300
lguest: use bool instead of int
Impact: clean up
Rusty told me, some time ago, that he had become a fan of "bool". So, here are some replacements.
drivers/lguest/core.c | 4 ++-- drivers/lguest/interrupts_and_traps.c | 21 +++++++++++---------- drivers/lguest/lg.h | 8 ++++---- drivers/lguest/page_tables.c | 18 +++++++++--------- drivers/lguest/segments.c | 2 +- 5 files changed, 27 insertions(+), 26 deletions(-)
commit 89a923c45472749805a9264fb409eb9c3cbad8e2
Author: Rusty Russell <[email protected]> Date: Sat Mar 28 23:39:19 2009 -0600
lguest: barrier me harder
Impact: barrier correctness in example launcher
I doubt either lguest user will complain about performance.
Documentation/lguest/lguest.c | 7 +++++++ 1 files changed, 7 insertions(+), 0 deletions(-)
Documentation/lguest/lguest.c +7 -0
@@ -1630,6 +1630,13 @@ static bool service_io(struct device *dev) } } +/* OK, so we noted that it was pretty poor to use an fdatasync as a +* barrier. But Christoph Hellwig points out that we need a sync +* *afterwards* as well: "Barriers specify no reordering to the front +* or the back." And Jens Axboe confirmed it, so here we are: */ +if (out->type &VIRTIO_BLK_T_BARRIER ) +fdatasync (vblk->fd); +/* We can't trigger an IRQ, because we're not the Launcher. It does * that when we tell it we're done. */ add_used (dev->vq, head, wlen);
arch/x86/include/asm/lguest_hcall.h +5 -20
@@ -17,6 +17,7 @@#define LHCALL_SET_PMD 15#define LHCALL_LOAD_TLS 16#define LHCALL_NOTIFY 17 +#define LHCALL_INVALIDATE_PGTABLE 18#define LGUEST_TRAP_ENTRY 0x1F
@@ -26,36 +27,20 @@#ifndef __ASSEMBLY__#include <asm/hw_irq.h> +#include <asm/kvm_para.h> /*G:031 But first, how does our Guest contact the Host to ask for privileged * operations? There are two ways: the direct way is to make a "hypercall", * to make requests of the Host Itself. * -* Our hypercall mechanism uses the highest unused trap code (traps 32 and -* above are used by real hardware interrupts). Fifteen hypercalls are +* We use the KVM hypercall mechanism. Eighteen hypercalls are * available: the hypercall number is put in the %eax register, and the -* arguments (when required) are placed in %edx, %ebx and %ecx. If a return +* arguments (when required) are placed in %ebx, %ecx and %edx. If a return * value makes sense, it's returned in %eax. * * Grossly invalid calls result in Sudden Death at the hands of the vengeful * Host, rather than returning failure. This reflects Winston Churchill's * definition of a gentleman: "someone who is only rude intentionally". */ -static inline unsigned long -hcall (unsigned long call, -unsigned long arg1,unsigned long arg2,unsigned long arg3) -{ -/* "int" is the Intel instruction to trigger a trap. */ - asm volatile("int $" __stringify(LGUEST_TRAP_ENTRY) - /* The call in %eax (aka "a") might be overwritten */ - : "=a"(call) - /* The arguments are in %eax, %edx, %ebx & %ecx */ - : "a"(call), "d"(arg1), "b"(arg2), "c"(arg3) - /* "memory" means this might write somewhere in memory. - * This isn't true for all calls, but it's safe to tell - * gcc that it might happen so it doesn't get clever. */ - : "memory"); -return call; -}/*:*/ /* Can't use our min() macro here: needs to be a constant */
@@ -64,7 +49,7 @@ hcall(unsigned long call,#define LHCALL_RING_SIZE 64struct hcall_args {/* These map directly onto eax, ebx, ecx, edx in struct lguest_regs */ -unsigned long arg0, arg2, arg3, arg1; +unsigned long arg0, arg1, arg2, arg3; };#endif /* !__ASSEMBLY__ */
arch/x86/lguest/boot.c +65 -29
259 lines not on this page · raw message
arch/x86/lguest/i386_head.S +2 -2
@@ -27,8 +27,8 @@ ENTRY(lguest_entry) /* We make the "initialization" hypercall now to tell the Host about * us, and also find out where it put our page tables. */ movl $LHCALL_LGUEST_INIT, %eax - movl $lguest_data - __PAGE_OFFSET, %edx - int $LGUEST_TRAP_ENTRY + movl $lguest_data - __PAGE_OFFSET, %ebx + .byte 0x0f,0x01,0xc1 /* KVM_HYPERCALL */ /* Set up the initial stack so we can run C code. */ movl $(init_thread_union+THREAD_SIZE),%esp
drivers/lguest/core.c +2 -2
@@ -152,8 +152,8 @@ static void unmap_switcher(void)* code. We have to check that the range is below the pfn_limit the Launcher * gave us. We have to make sure that addr + len doesn't give us a false * positive by overflowing, too. */ -int lguest_address_ok (const struct lguest *lg, -unsigned long addr,unsigned long len) +bool lguest_address_ok (const struct lguest *lg, +unsigned long addr,unsigned long len) {return (addr+len) /PAGE_SIZE < lg->pfn_limit && (addr+len >= addr); }
drivers/lguest/hypercalls.c +3 -0
@@ -92,6 +92,9 @@ static void do_hcall(struct lg_cpu *cpu, struct hcall_args *args)case LHCALL_NOTIFY : cpu->pending_notify = args->arg1;break ; +case LHCALL_INVALIDATE_PGTABLE : +invalidate_pagetable (cpu, args->arg1); +break ;default :/* It should be an architecture-specific hypercall. */ if (lguest_arch_do_hcall (cpu, args))
drivers/lguest/interrupts_and_traps.c +15 -13
@@ -34,7 +34,7 @@ static int idt_type(u32 lo, u32 hi) }/* An IDT entry can't be used unless the "present" bit is set. */ -static int idt_present (u32 lo,u32 hi) +static bool idt_present (u32 lo,u32 hi) {return (hi &0x8000 ); }
@@ -60,7 +60,8 @@ static void push_guest_stack(struct lg_cpu *cpu, unsigned long *gstack, u32 val)* We set up the stack just like the CPU does for a real interrupt, so it's * identical for the Guest (and the standard "iret" instruction will undo * it). */ -static void set_guest_interrupt (struct lg_cpu *cpu,u32 lo,u32 hi,int has_err) +static void set_guest_interrupt (struct lg_cpu *cpu,u32 lo,u32 hi, +bool has_err) {unsigned long gstack, origstack;u32 eflags, ss, irq_enable;
@@ -184,7 +185,7 @@ void maybe_do_interrupt(struct lg_cpu *cpu)/* set_guest_interrupt() takes the interrupt descriptor and a * flag to say whether this interrupt pushes an error code onto * the stack as well: virtual interrupts never do. */ -set_guest_interrupt (cpu, idt->a, idt->b,0 ); +set_guest_interrupt (cpu, idt->a, idt->b, false); }/* Every time we deliver an interrupt, we update the timestamp in the
@@ -244,26 +245,26 @@ void free_interrupts(void)/*H:220 Now we've got the routines to deliver interrupts, delivering traps like * page fault is easy. The only trick is that Intel decided that some traps * should have error codes: */ -static int has_err (unsigned int trap) +static bool has_err (unsigned int trap) {return (trap ==8 || (trap >=10 && trap <=14 ) || trap ==17 ); }/* deliver_trap() returns true if it could deliver the trap. */ -int deliver_trap (struct lg_cpu *cpu,unsigned int num) +bool deliver_trap (struct lg_cpu *cpu,unsigned int num) {/* Trap numbers are always 8 bit, but we set an impossible trap number * for traps inside the Switcher, so check that here. */ if (num >=ARRAY_SIZE (cpu->arch.idt)) -return 0 ; +return false;/* Early on the Guest hasn't set the IDT entries (or maybe it put a * bogus one in): if we fail here, the Guest will be killed. */ if (!idt_present (cpu->arch.idt[num].a, cpu->arch.idt[num].b)) -return 0 ; +return false;set_guest_interrupt (cpu, cpu->arch.idt[num].a, cpu->arch.idt[num].b,has_err (num)); -return 1 ; +return true; }/*H:250 Here's the hard part: returning to the Host every time a trap happens
@@ -279,18 +280,19 @@ int deliver_trap(struct lg_cpu *cpu, unsigned int num)* * This routine indicates if a particular trap number could be delivered * directly. */ -static int direct_trap (unsigned int num) +static bool direct_trap (unsigned int num) {/* Hardware interrupts don't go to the Guest at all (except system * call). */ if (num >=FIRST_EXTERNAL_VECTOR && !could_be_syscall (num)) -return 0 ; +return false;/* The Host needs to see page faults (for shadow paging and to save the * fault address), general protection faults (in/out emulation) and -* device not available (TS handling), and of course, the hypercall -* trap. */ -return num !=14 && num !=13 && num !=7 && num !=LGUEST_TRAP_ENTRY ; +* device not available (TS handling), invalid opcode fault (kvm hcall), +* and of course, the hypercall trap. */ +return num !=14 && num !=13 && num !=7 && + num !=6 && num !=LGUEST_TRAP_ENTRY ; }/*:*/
drivers/lguest/lg.h +5 -4
@@ -109,8 +109,8 @@ struct lguestextern struct mutex lguest_lock;/* core.c: */ -int lguest_address_ok (const struct lguest *lg, -unsigned long addr,unsigned long len); +bool lguest_address_ok (const struct lguest *lg, +unsigned long addr,unsigned long len);void __lgread (struct lg_cpu *,void *,unsigned long ,unsigned );void __lgwrite (struct lg_cpu *,unsigned long ,const void *,unsigned );
@@ -140,7 +140,7 @@ int run_guest(struct lg_cpu *cpu, unsigned long __user *user);/* interrupts_and_traps.c: */ void maybe_do_interrupt (struct lg_cpu *cpu); -int deliver_trap (struct lg_cpu *cpu,unsigned int num); +bool deliver_trap (struct lg_cpu *cpu,unsigned int num);void load_guest_idt_entry (struct lg_cpu *cpu,unsigned int i,u32 low,u32 hi);void guest_set_stack (struct lg_cpu *cpu,u32 seg,u32 esp,unsigned int pages);
@@ -173,7 +173,8 @@ void guest_pagetable_flush_user(struct lg_cpu *cpu);void guest_set_pte (struct lg_cpu *cpu,unsigned long gpgdir,unsigned long vaddr,pte_t val);void map_switcher_in_guest (struct lg_cpu *cpu,struct lguest_pages *pages); -int demand_page (struct lg_cpu *cpu,unsigned long cr2,int errcode); +bool demand_page (struct lg_cpu *cpu,unsigned long cr2,int errcode); +void invalidate_pagetable (struct lg_cpu *cpu,unsigned long pgtable);void pin_page (struct lg_cpu *cpu,unsigned long vaddr);unsigned long guest_pa (struct lg_cpu *cpu,unsigned long vaddr);void page_table_guest_data_init (struct lg_cpu *cpu);
drivers/lguest/lguest_device.c +2 -2
@@ -161,7 +161,7 @@ static void set_status(struct virtio_device *vdev, u8 status)/* We set the status. */ to_lgdev (vdev)->desc->status = status; -hcall (LHCALL_NOTIFY , (max_pfn<<PAGE_SHIFT ) + offset,0 ,0 ); +kvm_hypercall1 (LHCALL_NOTIFY , (max_pfn <<PAGE_SHIFT ) + offset); }static void lg_set_status (struct virtio_device *vdev,u8 status)
@@ -209,7 +209,7 @@ static void lg_notify(struct virtqueue *vq)* virtqueue structure. */ struct lguest_vq_info *lvq = vq->priv; -hcall (LHCALL_NOTIFY , lvq->config.pfn <<PAGE_SHIFT ,0 ,0 ); +kvm_hypercall1 (LHCALL_NOTIFY , lvq->config.pfn <<PAGE_SHIFT ); }/* An extern declaration inside a C file is bad form. Don't do it. */
drivers/lguest/page_tables.c +28 -10
@@ -199,7 +199,7 @@ static void check_gpgd(struct lg_cpu *cpu, pgd_t gpgd)* * If we fixed up the fault (ie. we mapped the address), this routine returns * true. Otherwise, it was a real fault and we need to tell the Guest. */ -int demand_page (struct lg_cpu *cpu,unsigned long vaddr,int errcode) +bool demand_page (struct lg_cpu *cpu,unsigned long vaddr,int errcode) {pgd_t gpgd;pgd_t *spgd;
@@ -211,7 +211,7 @@ int demand_page(struct lg_cpu *cpu, unsigned long vaddr, int errcode) gpgd =lgread (cpu,gpgd_addr (cpu, vaddr), pgd_t);/* Toplevel not present? We can't map it in. */ if (!(pgd_flags (gpgd) & _PAGE_PRESENT)) -return 0 ; +return false;/* Now look at the matching shadow entry. */ spgd =spgd_addr (cpu, cpu->cpu_pgd, vaddr);
@@ -222,7 +222,7 @@ int demand_page(struct lg_cpu *cpu, unsigned long vaddr, int errcode)* simple for this corner case. */ if (!ptepage) {kill_guest (cpu,"out of memory allocating pte page" ); -return 0 ; +return false; }/* We check that the Guest pgd is OK. */ check_gpgd (cpu, gpgd);
@@ -238,16 +238,16 @@ int demand_page(struct lg_cpu *cpu, unsigned long vaddr, int errcode)/* If this page isn't in the Guest page tables, we can't page it in. */ if (!(pte_flags (gpte) & _PAGE_PRESENT)) -return 0 ; +return false;/* Check they're not trying to write to a page the Guest wants * read-only (bit 2 of errcode == write). */ if ((errcode &2 ) && !(pte_flags (gpte) & _PAGE_RW)) -return 0 ; +return false;/* User access to a kernel-only page? (bit 3 == user access) */ if ((errcode &4 ) && !(pte_flags (gpte) & _PAGE_USER)) -return 0 ; +return false;/* Check that the Guest PTE flags are OK, and the page number is below * the pfn_limit (ie. not mapping the Launcher binary). */
@@ -283,7 +283,7 @@ int demand_page(struct lg_cpu *cpu, unsigned long vaddr, int errcode)* manipulated, the result returned and the code complete. A small * delay and a trace of alliteration are the only indications the Guest * has that a page fault occurred at all. */ -return 1 ; +return true; }/*H:360
@@ -296,7 +296,7 @@ int demand_page(struct lg_cpu *cpu, unsigned long vaddr, int errcode)* * This is a quick version which answers the question: is this virtual address * mapped by the shadow page tables, and is it writable? */ -static int page_writable (struct lg_cpu *cpu,unsigned long vaddr) +static bool page_writable (struct lg_cpu *cpu,unsigned long vaddr) {pgd_t *spgd;unsigned long flags;
@@ -304,7 +304,7 @@ static int page_writable(struct lg_cpu *cpu, unsigned long vaddr)/* Look at the current top level entry: is it present? */ spgd =spgd_addr (cpu, cpu->cpu_pgd, vaddr);if (!(pgd_flags (*spgd) & _PAGE_PRESENT)) -return 0 ; +return false;/* Check the flags on the pte entry itself: it must be present and * writable. */
@@ -373,8 +373,10 @@ unsigned long guest_pa(struct lg_cpu *cpu, unsigned long vaddr)/* First step: get the top-level Guest page table entry. */ gpgd =lgread (cpu,gpgd_addr (cpu, vaddr), pgd_t);/* Toplevel not present? We can't map it in. */ -if (!(pgd_flags (gpgd) & _PAGE_PRESENT)) +if (!(pgd_flags (gpgd) & _PAGE_PRESENT)) {kill_guest (cpu,"Bad address %#lx" , vaddr); +return -1UL ; + } gpte =lgread (cpu,gpte_addr (gpgd, vaddr), pte_t);if (!(pte_flags (gpte) & _PAGE_PRESENT))
@@ -449,6 +451,22 @@ void guest_new_pagetable(struct lg_cpu *cpu, unsigned long pgtable)pin_stack_pages (cpu); } +/* The Guest tells us when a page is no longer being used as a pagetable. +* Without this there can be a subtle bug where the same page gets re-used +* for a different process, and we think it's the same one as the one we have +* in our little pgdir cache. */ +void invalidate_pagetable (struct lg_cpu *cpu,unsigned long pgtable) +{ +unsigned int pgdir =find_pgdir (cpu->lg, pgtable); + +if (pgdir !=ARRAY_SIZE (cpu->lg->pgdirs)) { +if (pgdir == cpu->cpu_pgd) +kill_guest (cpu,"Attempt to invalidate in-use pgdir" ); +/* We set it to an invalid value. */ + cpu->lg->pgdirs[pgdir].gpgdir =-1UL ; + } +} +/*H:470 Finally, a routine which throws away everything: all PGD entries in all * the shadow page tables, including the Guest's kernel mappings. This is used * when we destroy the Guest. */
drivers/lguest/segments.c +1 -1
@@ -45,7 +45,7 @@* "Task State Segment" which controls all kinds of delicate things. The * LGUEST_CS and LGUEST_DS entries are reserved for the Switcher, and the * the Guest can't be trusted to deal with double faults. */ -static int ignored_gdt (unsigned int num) +static bool ignored_gdt (unsigned int num) {return (num ==GDT_ENTRY_TSS || num == GDT_ENTRY_LGUEST_CS
drivers/lguest/x86/core.c +61 -1
80 lines not on this page · raw message
drivers/virtio/virtio_ring.c +14 -8
@@ -23,15 +23,21 @@#ifdef DEBUG /* For development, we want to crash whenever the ring is screwed. */ -#define BAD_RING(vq, fmt...) \ - do { dev_err(&vq->vq.vdev->dev, fmt); BUG(); } while(0) -#define START_USE (vq) \ - do { if ((vq)->in_use) panic("in_use = %i\n", (vq)->in_use); (vq)->in_use = __LINE__; mb(); } while(0) -#define END_USE (vq) \ - do { BUG_ON(!(vq)->in_use); (vq)->in_use = 0; mb(); } while(0) +#define BAD_RING(_vq, fmt...) \ + do { dev_err(&(_vq)->vq.vdev->dev, fmt); BUG(); } while(0) +/* Caller is supposed to guarantee no reentry. */ +#define START_USE (_vq) \ + do { \ + if ((_vq)->in_use) \ + panic("in_use = %i\n", (_vq)->in_use); \ + (_vq)->in_use = __LINE__; \ + mb(); \ + } while(0) +#define END_USE (_vq) \ + do { BUG_ON(!(_vq)->in_use); (_vq)->in_use = 0; mb(); } while(0)#else -#define BAD_RING(vq, fmt...) \ - do { dev_err(&vq->vq.vdev->dev, fmt); (vq)->broken = true; } while(0) +#define BAD_RING(_vq, fmt...) \ + do { dev_err(&_vq->vq.vdev->dev, fmt); (_vq)->broken = true; } while(0)#define START_USE (vq)#define END_USE (vq)#endif
Quoted 1 line · On Saturday 28 March 2009 23:41:54 Rusty Russell wrote:
The following changes since commit
5d80f8e5a9dc9c9a94d4aeaa567e219a808b8a4a:
...
Quoted 1 line
lguest: avoid accidental recycling of pgdir pages
Actually, I've repushed without this change: Jeremy convinced me it's not necessary.
If you pulled in between, it's no big deal.
Rusty.
New stats:
Matias Zabaljauregui (2):
lguest: use KVM hypercalls
lguest: use bool instead of int
Roel Kluin (1):
virtio: fix BAD_RING, START_US and END_USE macros
Rusty Russell (4):
virtio: more neatening of virtio_ring macros.
lguest: fix spurious BUG_ON() on invalid guest stack.
lguest: wire up pte_update/pte_update_defer
lguest: barrier me harder
Documentation/lguest/lguest.c | 7 +++ arch/x86/include/asm/lguest_hcall.h | 24 ++-------- arch/x86/lguest/boot.c | 86 ++++++++++++++++++++++----------- arch/x86/lguest/i386_head.S | 4 +- drivers/lguest/core.c | 4 +- drivers/lguest/interrupts_and_traps.c | 28 ++++++----- drivers/lguest/lg.h | 8 ++-- drivers/lguest/lguest_device.c | 4 +- drivers/lguest/page_tables.c | 22 +++++---- drivers/lguest/segments.c | 2 +- drivers/lguest/x86/core.c | 62 +++++++++++++++++++++++- drivers/virtio/virtio_ring.c | 22 +++++--- 12 files changed, 181 insertions(+), 92 deletions(-)