Commit fc708b3e authored by Glauber de Oliveira Costa's avatar Glauber de Oliveira Costa Committed by Rusty Russell
Browse files

lguest: replace lguest_arch with lg_cpu_arch. 



The fields found in lguest_arch are not really per-guest,
but per-cpu (gdt, idt, etc). So this patch turns lguest_arch
into lg_cpu_arch.

It makes sense to have a per-guest per-arch struct, but this
can be addressed later, when the need arrives.

Signed-off-by: default avatarGlauber de Oliveira Costa <gcosta@redhat.com>
Signed-off-by: default avatarRusty Russell <rusty@rustcorp.com.au>
parent a53a35a8

drivers/lguest/interrupts_and_traps.c

+14 −14
Original line number Diff line number Diff line
@@ -178,7 +178,7 @@ void maybe_do_interrupt(struct lg_cpu *cpu) 
	/* Look at the IDT entry the Guest gave us for this interrupt.  The

	 * first 32 (FIRST_EXTERNAL_VECTOR) entries are for traps, so we skip

	 * over them. */

	idt = &lg->arch.idt[FIRST_EXTERNAL_VECTOR+irq];

	idt = &cpu->arch.idt[FIRST_EXTERNAL_VECTOR+irq];

	/* If they don't have a handler (yet?), we just ignore it */

	if (idt_present(idt->a, idt->b)) {

		/* OK, mark it no longer pending and deliver it. */
@@ -251,15 +251,15 @@ int 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->lg->arch.idt))

	if (num >= ARRAY_SIZE(cpu->arch.idt))

		return 0;



	/* 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->lg->arch.idt[num].a, cpu->lg->arch.idt[num].b))

	if (!idt_present(cpu->arch.idt[num].a, cpu->arch.idt[num].b))

		return 0;

	set_guest_interrupt(cpu, cpu->lg->arch.idt[num].a,

			    cpu->lg->arch.idt[num].b, has_err(num));

	set_guest_interrupt(cpu, cpu->arch.idt[num].a,

			    cpu->arch.idt[num].b, has_err(num));

	return 1;

}
@@ -385,7 +385,7 @@ static void set_trap(struct lguest *lg, struct desc_struct *trap, 
 *

 * We saw the Guest setting Interrupt Descriptor Table (IDT) entries with the

 * LHCALL_LOAD_IDT_ENTRY hypercall before: that comes here. */

void load_guest_idt_entry(struct lguest *lg, unsigned int num, u32 lo, u32 hi)

void load_guest_idt_entry(struct lg_cpu *cpu, unsigned int num, u32 lo, u32 hi)

{

	/* Guest never handles: NMI, doublefault, spurious interrupt or

	 * hypercall.  We ignore when it tries to set them. */
@@ -394,13 +394,13 @@ void load_guest_idt_entry(struct lguest *lg, unsigned int num, u32 lo, u32 hi) 


	/* Mark the IDT as changed: next time the Guest runs we'll know we have

	 * to copy this again. */

	lg->changed |= CHANGED_IDT;

	cpu->lg->changed |= CHANGED_IDT;



	/* Check that the Guest doesn't try to step outside the bounds. */

	if (num >= ARRAY_SIZE(lg->arch.idt))

		kill_guest(lg, "Setting idt entry %u", num);

	if (num >= ARRAY_SIZE(cpu->arch.idt))

		kill_guest(cpu->lg, "Setting idt entry %u", num);

	else

		set_trap(lg, &lg->arch.idt[num], num, lo, hi);

		set_trap(cpu->lg, &cpu->arch.idt[num], num, lo, hi);

}



/* The default entry for each interrupt points into the Switcher routines which
@@ -436,14 +436,14 @@ void setup_default_idt_entries(struct lguest_ro_state *state, 
/*H:240 We don't use the IDT entries in the "struct lguest" directly, instead

 * we copy them into the IDT which we've set up for Guests on this CPU, just

 * before we run the Guest.  This routine does that copy. */

void copy_traps(const struct lguest *lg, struct desc_struct *idt,

void copy_traps(const struct lg_cpu *cpu, struct desc_struct *idt,

		const unsigned long *def)

{

	unsigned int i;



	/* We can simply copy the direct traps, otherwise we use the default

	 * ones in the Switcher: they will return to the Host. */

	for (i = 0; i < ARRAY_SIZE(lg->arch.idt); i++) {

	for (i = 0; i < ARRAY_SIZE(cpu->arch.idt); i++) {

		/* If no Guest can ever override this trap, leave it alone. */

		if (!direct_trap(i))

			continue;
@@ -452,8 +452,8 @@ void copy_traps(const struct lguest *lg, struct desc_struct *idt, 
		 * Interrupt gates (type 14) disable interrupts as they are

		 * entered, which we never let the Guest do.  Not present

		 * entries (type 0x0) also can't go direct, of course. */

		if (idt_type(lg->arch.idt[i].a, lg->arch.idt[i].b) == 0xF)

			idt[i] = lg->arch.idt[i];

		if (idt_type(cpu->arch.idt[i].a, cpu->arch.idt[i].b) == 0xF)

			idt[i] = cpu->arch.idt[i];

		else

			/* Reset it to the default. */

			default_idt_entry(&idt[i], i, def[i]);

drivers/lguest/lg.h

+10 −9
Original line number Diff line number Diff line
@@ -57,6 +57,8 @@ struct lg_cpu { 


	/* Pending virtual interrupts */

	DECLARE_BITMAP(irqs_pending, LGUEST_IRQS);



	struct lg_cpu_arch arch;

};



/* The private info the thread maintains about the guest. */
@@ -99,8 +101,6 @@ struct lguest 


	/* Dead? */

	const char *dead;



	struct lguest_arch arch;

};



extern struct mutex lguest_lock;
@@ -139,12 +139,13 @@ 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);

void load_guest_idt_entry(struct lguest *lg, unsigned int i, u32 low, u32 hi);

void load_guest_idt_entry(struct lg_cpu *cpu, unsigned int i,

			  u32 low, u32 hi);

void guest_set_stack(struct lguest *lg, u32 seg, u32 esp, unsigned int pages);

void pin_stack_pages(struct lguest *lg);

void setup_default_idt_entries(struct lguest_ro_state *state,

			       const unsigned long *def);

void copy_traps(const struct lguest *lg, struct desc_struct *idt,

void copy_traps(const struct lg_cpu *cpu, struct desc_struct *idt,

		const unsigned long *def);

void guest_set_clockevent(struct lg_cpu *cpu, unsigned long delta);

void init_clockdev(struct lg_cpu *cpu);
@@ -154,11 +155,11 @@ void free_interrupts(void); 


/* segments.c: */

void setup_default_gdt_entries(struct lguest_ro_state *state);

void setup_guest_gdt(struct lguest *lg);

void load_guest_gdt(struct lguest *lg, unsigned long table, u32 num);

void guest_load_tls(struct lguest *lg, unsigned long tls_array);

void copy_gdt(const struct lguest *lg, struct desc_struct *gdt);

void copy_gdt_tls(const struct lguest *lg, struct desc_struct *gdt);

void setup_guest_gdt(struct lg_cpu *cpu);

void load_guest_gdt(struct lg_cpu *cpu, unsigned long table, u32 num);

void guest_load_tls(struct lg_cpu *cpu, unsigned long tls_array);

void copy_gdt(const struct lg_cpu *cpu, struct desc_struct *gdt);

void copy_gdt_tls(const struct lg_cpu *cpu, struct desc_struct *gdt);



/* page_tables.c: */

int init_guest_pagetable(struct lguest *lg, unsigned long pgtable);

drivers/lguest/segments.c

+22 −20
Original line number Diff line number Diff line
@@ -58,7 +58,7 @@ static int ignored_gdt(unsigned int num) 
 * Protection Fault in the Switcher when it restores a Guest segment register

 * which tries to use that entry.  Then we kill the Guest for causing such a

 * mess: the message will be "unhandled trap 256". */

static void fixup_gdt_table(struct lguest *lg, unsigned start, unsigned end)

static void fixup_gdt_table(struct lg_cpu *cpu, unsigned start, unsigned end)

{

	unsigned int i;
@@ -71,14 +71,14 @@ static void fixup_gdt_table(struct lguest *lg, unsigned start, unsigned end) 
		/* Segment descriptors contain a privilege level: the Guest is

		 * sometimes careless and leaves this as 0, even though it's

		 * running at privilege level 1.  If so, we fix it here. */

		if ((lg->arch.gdt[i].b & 0x00006000) == 0)

			lg->arch.gdt[i].b |= (GUEST_PL << 13);

		if ((cpu->arch.gdt[i].b & 0x00006000) == 0)

			cpu->arch.gdt[i].b |= (GUEST_PL << 13);



		/* Each descriptor has an "accessed" bit.  If we don't set it

		 * now, the CPU will try to set it when the Guest first loads

		 * that entry into a segment register.  But the GDT isn't

		 * writable by the Guest, so bad things can happen. */

		lg->arch.gdt[i].b |= 0x00000100;

		cpu->arch.gdt[i].b |= 0x00000100;

	}

}
@@ -109,31 +109,31 @@ void setup_default_gdt_entries(struct lguest_ro_state *state) 


/* This routine sets up the initial Guest GDT for booting.  All entries start

 * as 0 (unusable). */

void setup_guest_gdt(struct lguest *lg)

void setup_guest_gdt(struct lg_cpu *cpu)

{

	/* Start with full 0-4G segments... */

	lg->arch.gdt[GDT_ENTRY_KERNEL_CS] = FULL_EXEC_SEGMENT;

	lg->arch.gdt[GDT_ENTRY_KERNEL_DS] = FULL_SEGMENT;

	cpu->arch.gdt[GDT_ENTRY_KERNEL_CS] = FULL_EXEC_SEGMENT;

	cpu->arch.gdt[GDT_ENTRY_KERNEL_DS] = FULL_SEGMENT;

	/* ...except the Guest is allowed to use them, so set the privilege

	 * level appropriately in the flags. */

	lg->arch.gdt[GDT_ENTRY_KERNEL_CS].b |= (GUEST_PL << 13);

	lg->arch.gdt[GDT_ENTRY_KERNEL_DS].b |= (GUEST_PL << 13);

	cpu->arch.gdt[GDT_ENTRY_KERNEL_CS].b |= (GUEST_PL << 13);

	cpu->arch.gdt[GDT_ENTRY_KERNEL_DS].b |= (GUEST_PL << 13);

}



/*H:650 An optimization of copy_gdt(), for just the three "thead-local storage"

 * entries. */

void copy_gdt_tls(const struct lguest *lg, struct desc_struct *gdt)

void copy_gdt_tls(const struct lg_cpu *cpu, struct desc_struct *gdt)

{

	unsigned int i;



	for (i = GDT_ENTRY_TLS_MIN; i <= GDT_ENTRY_TLS_MAX; i++)

		gdt[i] = lg->arch.gdt[i];

		gdt[i] = cpu->arch.gdt[i];

}



/*H:640 When the Guest is run on a different CPU, or the GDT entries have

 * changed, copy_gdt() is called to copy the Guest's GDT entries across to this

 * CPU's GDT. */

void copy_gdt(const struct lguest *lg, struct desc_struct *gdt)

void copy_gdt(const struct lg_cpu *cpu, struct desc_struct *gdt)

{

	unsigned int i;
@@ -141,21 +141,22 @@ void copy_gdt(const struct lguest *lg, struct desc_struct *gdt) 
	 * replaced.  See ignored_gdt() above. */

	for (i = 0; i < GDT_ENTRIES; i++)

		if (!ignored_gdt(i))

			gdt[i] = lg->arch.gdt[i];

			gdt[i] = cpu->arch.gdt[i];

}



/*H:620 This is where the Guest asks us to load a new GDT (LHCALL_LOAD_GDT).

 * We copy it from the Guest and tweak the entries. */

void load_guest_gdt(struct lguest *lg, unsigned long table, u32 num)

void load_guest_gdt(struct lg_cpu *cpu, unsigned long table, u32 num)

{

	struct lguest *lg = cpu->lg;

	/* We assume the Guest has the same number of GDT entries as the

	 * Host, otherwise we'd have to dynamically allocate the Guest GDT. */

	if (num > ARRAY_SIZE(lg->arch.gdt))

	if (num > ARRAY_SIZE(cpu->arch.gdt))

		kill_guest(lg, "too many gdt entries %i", num);



	/* We read the whole thing in, then fix it up. */

	__lgread(lg, lg->arch.gdt, table, num * sizeof(lg->arch.gdt[0]));

	fixup_gdt_table(lg, 0, ARRAY_SIZE(lg->arch.gdt));

	__lgread(lg, cpu->arch.gdt, table, num * sizeof(cpu->arch.gdt[0]));

	fixup_gdt_table(cpu, 0, ARRAY_SIZE(cpu->arch.gdt));

	/* Mark that the GDT changed so the core knows it has to copy it again,

	 * even if the Guest is run on the same CPU. */

	lg->changed |= CHANGED_GDT;
@@ -165,12 +166,13 @@ void load_guest_gdt(struct lguest *lg, unsigned long table, u32 num) 
 * Remember that this happens on every context switch, so it's worth

 * optimizing.  But wouldn't it be neater to have a single hypercall to cover

 * both cases? */

void guest_load_tls(struct lguest *lg, unsigned long gtls)

void guest_load_tls(struct lg_cpu *cpu, unsigned long gtls)

{

	struct desc_struct *tls = &lg->arch.gdt[GDT_ENTRY_TLS_MIN];

	struct desc_struct *tls = &cpu->arch.gdt[GDT_ENTRY_TLS_MIN];

	struct lguest *lg = cpu->lg;



	__lgread(lg, tls, gtls, sizeof(*tls)*GDT_ENTRY_TLS_ENTRIES);

	fixup_gdt_table(lg, GDT_ENTRY_TLS_MIN, GDT_ENTRY_TLS_MAX+1);

	fixup_gdt_table(cpu, GDT_ENTRY_TLS_MIN, GDT_ENTRY_TLS_MAX+1);

	/* Note that just the TLS entries have changed. */

	lg->changed |= CHANGED_GDT_TLS;

}

drivers/lguest/x86/core.c

+11 −13
Original line number Diff line number Diff line
@@ -100,14 +100,14 @@ static void copy_in_guest_info(struct lg_cpu *cpu, struct lguest_pages *pages) 


	/* Copy direct-to-Guest trap entries. */

	if (lg->changed & CHANGED_IDT)

		copy_traps(lg, pages->state.guest_idt, default_idt_entries);

		copy_traps(cpu, pages->state.guest_idt, default_idt_entries);



	/* Copy all GDT entries which the Guest can change. */

	if (lg->changed & CHANGED_GDT)

		copy_gdt(lg, pages->state.guest_gdt);

		copy_gdt(cpu, pages->state.guest_gdt);

	/* If only the TLS entries have changed, copy them. */

	else if (lg->changed & CHANGED_GDT_TLS)

		copy_gdt_tls(lg, pages->state.guest_gdt);

		copy_gdt_tls(cpu, pages->state.guest_gdt);



	/* Mark the Guest as unchanged for next time. */

	lg->changed = 0;
@@ -196,7 +196,7 @@ void lguest_arch_run_guest(struct lg_cpu *cpu) 
	 * re-enable interrupts an interrupt could fault and thus overwrite

	 * cr2, or we could even move off to a different CPU. */

	if (cpu->regs->trapnum == 14)

		lg->arch.last_pagefault = read_cr2();

		cpu->arch.last_pagefault = read_cr2();

	/* Similarly, if we took a trap because the Guest used the FPU,

	 * we have to restore the FPU it expects to see. */

	else if (cpu->regs->trapnum == 7)
@@ -307,7 +307,7 @@ void lguest_arch_handle_trap(struct lg_cpu *cpu) 
		 *

		 * The errcode tells whether this was a read or a write, and

		 * whether kernel or userspace code. */

		if (demand_page(lg, lg->arch.last_pagefault, cpu->regs->errcode))

		if (demand_page(lg,cpu->arch.last_pagefault,cpu->regs->errcode))

			return;



		/* OK, it's really not there (or not OK): the Guest needs to
@@ -318,7 +318,7 @@ void lguest_arch_handle_trap(struct lg_cpu *cpu) 
		 * happen before it's done the LHCALL_LGUEST_INIT hypercall, so

		 * lg->lguest_data could be NULL */

		if (lg->lguest_data &&

		    put_user(lg->arch.last_pagefault, &lg->lguest_data->cr2))

		    put_user(cpu->arch.last_pagefault, &lg->lguest_data->cr2))

			kill_guest(lg, "Writing cr2");

		break;

	case 7: /* We've intercepted a Device Not Available fault. */
@@ -349,7 +349,7 @@ void lguest_arch_handle_trap(struct lg_cpu *cpu) 
		 * it handle), it dies with a cryptic error message. */

		kill_guest(lg, "unhandled trap %li at %#lx (%#lx)",

			   cpu->regs->trapnum, cpu->regs->eip,

			   cpu->regs->trapnum == 14 ? lg->arch.last_pagefault

			   cpu->regs->trapnum == 14 ? cpu->arch.last_pagefault

			   : cpu->regs->errcode);

}
@@ -495,17 +495,15 @@ void __exit lguest_arch_host_fini(void) 
/*H:122 The i386-specific hypercalls simply farm out to the right functions. */

int lguest_arch_do_hcall(struct lg_cpu *cpu, struct hcall_args *args)

{

	struct lguest *lg = cpu->lg;



	switch (args->arg0) {

	case LHCALL_LOAD_GDT:

		load_guest_gdt(lg, args->arg1, args->arg2);

		load_guest_gdt(cpu, args->arg1, args->arg2);

		break;

	case LHCALL_LOAD_IDT_ENTRY:

		load_guest_idt_entry(lg, args->arg1, args->arg2, args->arg3);

		load_guest_idt_entry(cpu, args->arg1, args->arg2, args->arg3);

		break;

	case LHCALL_LOAD_TLS:

		guest_load_tls(lg, args->arg1);

		guest_load_tls(cpu, args->arg1);

		break;

	default:

		/* Bad Guest.  Bad! */
@@ -586,5 +584,5 @@ void lguest_arch_setup_regs(struct lg_cpu *cpu, unsigned long start) 


	/* There are a couple of GDT entries the Guest expects when first

	 * booting. */

	setup_guest_gdt(cpu->lg);

	setup_guest_gdt(cpu);

}

include/asm-x86/lguest.h

+1 −1
Original line number Diff line number Diff line
@@ -56,7 +56,7 @@ struct lguest_ro_state 
	struct desc_struct guest_gdt[GDT_ENTRIES];

};



struct lguest_arch

struct lg_cpu_arch

{

	/* The GDT entries copied into lguest_ro_state when running. */

	struct desc_struct gdt[GDT_ENTRIES];

CRA Git | Maintained and supported by SUSTech CRA and CCSE