Allow guest to specify syscall vector to use. (c18acd73) · Commits · e / devices / android_kernel_teracube_emerald

arch/x86/lguest/boot.c

+1 −0

Original line number	Original line	Diff line number	Diff line
	@@ -87,6 +87,7 @@ struct lguest_data lguest_data = {
	.noirq_start = (u32)lguest_noirq_start,		.noirq_start = (u32)lguest_noirq_start,
	.noirq_end = (u32)lguest_noirq_end,		.noirq_end = (u32)lguest_noirq_end,
	.blocked_interrupts = { 1 }, /* Block timer interrupts */		.blocked_interrupts = { 1 }, /* Block timer interrupts */
			.syscall_vec = SYSCALL_VECTOR,
	};		};
	static cycle_t clock_base;		static cycle_t clock_base;

drivers/lguest/core.c

+20 −10

Original line number	Original line	Diff line number	Diff line
	@@ -281,37 +281,47 @@ static int __init init(void)
	/* First we put the Switcher up in very high virtual memory. */		/* First we put the Switcher up in very high virtual memory. */
	err = map_switcher();		err = map_switcher();
	if (err)		if (err)
	return err;		goto out;

	/* Now we set up the pagetable implementation for the Guests. */		/* Now we set up the pagetable implementation for the Guests. */
	err = init_pagetables(switcher_page, SHARED_SWITCHER_PAGES);		err = init_pagetables(switcher_page, SHARED_SWITCHER_PAGES);
	if (err) {		if (err)
	unmap_switcher();		goto unmap;
	return err;
	}

	/* The I/O subsystem needs some things initialized. */		/* The I/O subsystem needs some things initialized. */
	lguest_io_init();		lguest_io_init();

			/* We might need to reserve an interrupt vector. */
			err = init_interrupts();
			if (err)
			goto free_pgtables;

	/* /dev/lguest needs to be registered. */		/* /dev/lguest needs to be registered. */
	err = lguest_device_init();		err = lguest_device_init();
	if (err) {		if (err)
	free_pagetables();		goto free_interrupts;
	unmap_switcher();
	return err;
	}

	/* Finally we do some architecture-specific setup. */		/* Finally we do some architecture-specific setup. */
	lguest_arch_host_init();		lguest_arch_host_init();

	/* All good! */		/* All good! */
	return 0;		return 0;

			free_interrupts:
			free_interrupts();
			free_pgtables:
			free_pagetables();
			unmap:
			unmap_switcher();
			out:
			return err;
	}		}

	/* Cleaning up is just the same code, backwards. With a little French. */		/* Cleaning up is just the same code, backwards. With a little French. */
	static void __exit fini(void)		static void __exit fini(void)
	{		{
	lguest_device_remove();		lguest_device_remove();
			free_interrupts();
	free_pagetables();		free_pagetables();
	unmap_switcher();		unmap_switcher();

drivers/lguest/interrupts_and_traps.c

+48 −1

Original line number	Original line	Diff line number	Diff line
	@@ -12,8 +12,14 @@
	* them first, so we also have a way of "reflecting" them into the Guest as if		* them first, so we also have a way of "reflecting" them into the Guest as if
	* they had been delivered to it directly. :*/		* they had been delivered to it directly. :*/
	#include <linux/uaccess.h>		#include <linux/uaccess.h>
			#include <linux/interrupt.h>
			#include <linux/module.h>
	#include "lg.h"		#include "lg.h"

			/* Allow Guests to use a non-128 (ie. non-Linux) syscall trap. */
			static unsigned int syscall_vector = SYSCALL_VECTOR;
			module_param(syscall_vector, uint, 0444);

	/* The address of the interrupt handler is split into two bits: */		/* The address of the interrupt handler is split into two bits: */
	static unsigned long idt_address(u32 lo, u32 hi)		static unsigned long idt_address(u32 lo, u32 hi)
	{		{
	@@ -183,6 +189,47 @@ void maybe_do_interrupt(struct lguest *lg)
	* timer interrupt. */		* timer interrupt. */
	write_timestamp(lg);		write_timestamp(lg);
	}		}
			/:/

			/* Linux uses trap 128 for system calls. Plan9 uses 64, and Ron Minnich sent
			* me a patch, so we support that too. It'd be a big step for lguest if half
			* the Plan 9 user base were to start using it.
			*
			* Actually now I think of it, it's possible that Ron is half the Plan 9
			* userbase. Oh well. */
			static bool could_be_syscall(unsigned int num)
			{
			/* Normal Linux SYSCALL_VECTOR or reserved vector? */
			return num == SYSCALL_VECTOR \|\| num == syscall_vector;
			}

			/* The syscall vector it wants must be unused by Host. */
			bool check_syscall_vector(struct lguest *lg)
			{
			u32 vector;

			if (get_user(vector, &lg->lguest_data->syscall_vec))
			return false;

			return could_be_syscall(vector);
			}

			int init_interrupts(void)
			{
			/* If they want some strange system call vector, reserve it now */
			if (syscall_vector != SYSCALL_VECTOR
			&& test_and_set_bit(syscall_vector, used_vectors)) {
			printk("lg: couldn't reserve syscall %u\n", syscall_vector);
			return -EBUSY;
			}
			return 0;
			}

			void free_interrupts(void)
			{
			if (syscall_vector != SYSCALL_VECTOR)
			clear_bit(syscall_vector, used_vectors);
			}

	/*H:220 Now we've got the routines to deliver interrupts, delivering traps		/*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		* like page fault is easy. The only trick is that Intel decided that some
	@@ -224,7 +271,7 @@ static int direct_trap(unsigned int num)
	{		{
	/* Hardware interrupts don't go to the Guest at all (except system		/* Hardware interrupts don't go to the Guest at all (except system
	* call). */		* call). */
	if (num >= FIRST_EXTERNAL_VECTOR && num != SYSCALL_VECTOR)		if (num >= FIRST_EXTERNAL_VECTOR && !could_be_syscall(num))
	return 0;		return 0;

	/* The Host needs to see page faults (for shadow paging and to save the		/* The Host needs to see page faults (for shadow paging and to save the

drivers/lguest/lg.h

+3 −0

Original line number	Original line	Diff line number	Diff line
	@@ -141,6 +141,9 @@ void copy_traps(const struct lguest lg, struct desc_struct idt,
	const unsigned long *def);		const unsigned long *def);
	void guest_set_clockevent(struct lguest *lg, unsigned long delta);		void guest_set_clockevent(struct lguest *lg, unsigned long delta);
	void init_clockdev(struct lguest *lg);		void init_clockdev(struct lguest *lg);
			bool check_syscall_vector(struct lguest *lg);
			int init_interrupts(void);
			void free_interrupts(void);

	/* segments.c: */		/* segments.c: */
	void setup_default_gdt_entries(struct lguest_ro_state *state);		void setup_default_gdt_entries(struct lguest_ro_state *state);

drivers/lguest/x86/core.c

+4 −0

Original line number	Original line	Diff line number	Diff line
	@@ -530,6 +530,10 @@ int lguest_arch_init_hypercalls(struct lguest *lg)
	if (put_user(tsc_speed, &lg->lguest_data->tsc_khz))		if (put_user(tsc_speed, &lg->lguest_data->tsc_khz))
	return -EFAULT;		return -EFAULT;

			/* The interrupt code might not like the system call vector. */
			if (!check_syscall_vector(lg))
			kill_guest(lg, "bad syscall vector");

	return 0;		return 0;
	}		}
	/* Now we've examined the hypercall code; our Guest can make requests. There		/* Now we've examined the hypercall code; our Guest can make requests. There