From: Peter Dinda Date: Tue, 26 Jun 2012 21:27:41 +0000 (-0500) Subject: Changes to linux interfaces: X-Git-Url: http://v3vee.org/palacios/gitweb/gitweb.cgi?a=commitdiff_plain;h=fe436f3769306b960087068610f9afc85b7141ba;hp=b21e50b2ddee22d01640350b676e48ac2b0d579d;p=palacios.git Changes to linux interfaces: - relevant palacios stubs exposed globally so other linux_module code can use them - irq_save and irq_restore versions of mutex locks directly exposed to allow linux lock debugging features to work across linux and palacios - timed yield - global proc dir --- diff --git a/linux_module/main.c b/linux_module/main.c index b7fecea..df1c98c 100644 --- a/linux_module/main.c +++ b/linux_module/main.c @@ -44,7 +44,7 @@ int mod_frees = 0; static int v3_major_num = 0; static struct v3_guest * guest_map[MAX_VMS] = {[0 ... MAX_VMS - 1] = 0}; -static struct proc_dir_entry *dir; +static struct proc_dir_entry *dir = 0; struct class * v3_class = NULL; static struct cdev ctrl_dev; @@ -174,6 +174,11 @@ static struct file_operations v3_ctrl_fops = { +struct proc_dir_entry *palacios_get_procdir(void) +{ + return dir; +} + static int read_guests(char * buf, char ** start, off_t off, int count, int * eof, void * data) { diff --git a/linux_module/palacios-stubs.c b/linux_module/palacios-stubs.c index 0d4240b..78759d0 100644 --- a/linux_module/palacios-stubs.c +++ b/linux_module/palacios-stubs.c @@ -45,6 +45,7 @@ static char *print_buffer[NR_CPUS]; static void deinit_print_buffers(void) { int i; + for (i=0;ifn(thread_info->arg); - INFO("Palacios Thread (%s) EXITTING\n", thread_info->name); + INFO("Palacios Thread (%s) EXITING\n", thread_info->name); kfree(thread_info); // handle cleanup @@ -269,7 +270,7 @@ static int lnx_thread_target(void * arg) { /** * Creates a kernel thread. */ -static void * +void * palacios_start_kernel_thread( int (*fn) (void * arg), void * arg, @@ -288,7 +289,7 @@ palacios_start_kernel_thread( /** * Starts a kernel thread on the specified CPU. */ -static void * +void * palacios_start_thread_on_cpu(int cpu_id, int (*fn)(void * arg), void * arg, @@ -324,7 +325,7 @@ palacios_start_thread_on_cpu(int cpu_id, * The thread will be running on target CPU on return * non-zero return means failure */ -static int +int palacios_move_thread_to_cpu(int new_cpu_id, void * thread_ptr) { struct task_struct * thread = (struct task_struct *)thread_ptr; @@ -485,7 +486,7 @@ palacios_ack_interrupt( /** * Returns the CPU frequency in kilohertz. */ -static unsigned int +unsigned int palacios_get_cpu_khz(void) { INFO("cpu_khz is %u\n", cpu_khz); @@ -501,21 +502,37 @@ palacios_get_cpu_khz(void) /** * Yield the CPU so other host OS tasks can run. + * This will return immediately if there is no other thread that is runnable + * And there is no real bound on how long it will yield */ -static void +void palacios_yield_cpu(void) { schedule(); return; } +/** + * Yield the CPU so other host OS tasks can run. + * Given now immediately if there is no other thread that is runnable + * And there is no real bound on how long it will yield + */ +void palacios_yield_cpu_timed(unsigned int us) +{ + unsigned int jiffies = 1000000U * HZ / us; + + set_current_state(TASK_INTERRUPTIBLE); + + schedule_timeout(jiffies); + +} /** * Allocates a mutex. * Returns NULL on failure. */ -static void * +void * palacios_mutex_alloc(void) { spinlock_t *lock = kmalloc(sizeof(spinlock_t), GFP_KERNEL); @@ -530,7 +547,7 @@ palacios_mutex_alloc(void) /** * Frees a mutex. */ -static void +void palacios_mutex_free(void * mutex) { kfree(mutex); } @@ -538,15 +555,30 @@ palacios_mutex_free(void * mutex) { /** * Locks a mutex. */ -static void +void palacios_mutex_lock(void * mutex, int must_spin) { spin_lock((spinlock_t *)mutex); } + +/** + * Locks a mutex, disabling interrupts on this core + */ +void * +palacios_mutex_lock_irqsave(void * mutex, int must_spin) { + + unsigned long flags; + + spin_lock_irqsave((spinlock_t *)mutex,flags); + + return (void *)flags; +} + + /** * Unlocks a mutex. */ -static void +void palacios_mutex_unlock( void * mutex ) @@ -554,6 +586,17 @@ palacios_mutex_unlock( spin_unlock((spinlock_t *)mutex); } + +/** + * Unlocks a mutex. + */ +void +palacios_mutex_unlock_irqrestore(void *mutex, void *flags) +{ + // This is correct, flags is opaque + spin_unlock_irqrestore((spinlock_t *)mutex,(unsigned long)flags); +} + /** * Structure used by the Palacios hypervisor to interface with the host kernel. */ @@ -570,10 +613,13 @@ static struct v3_os_hooks palacios_os_hooks = { .get_cpu_khz = palacios_get_cpu_khz, .start_kernel_thread = palacios_start_kernel_thread, .yield_cpu = palacios_yield_cpu, + .yield_cpu_timed = palacios_yield_cpu_timed, .mutex_alloc = palacios_mutex_alloc, .mutex_free = palacios_mutex_free, .mutex_lock = palacios_mutex_lock, .mutex_unlock = palacios_mutex_unlock, + .mutex_lock_irqsave = palacios_mutex_lock_irqsave, + .mutex_unlock_irqrestore= palacios_mutex_unlock_irqrestore, .get_cpu = palacios_get_cpu, .interrupt_cpu = palacios_interrupt_cpu, .call_on_cpu = palacios_xcall, @@ -618,7 +664,7 @@ int palacios_vmm_init( void ) memset(irq_to_guest_map, 0, sizeof(struct v3_vm_info *) * 256); - if (init_print_buffers(num_cpus)) { + if (init_print_buffers()) { ERROR("Cannot initialize print buffers\n"); kfree(cpu_mask); return -1; diff --git a/linux_module/palacios.h b/linux_module/palacios.h index e57fbd4..ff1d884 100644 --- a/linux_module/palacios.h +++ b/linux_module/palacios.h @@ -98,9 +98,31 @@ int palacios_vmm_init( void ); int palacios_vmm_exit( void ); -// Exported stubs, for use in other palacios components, like vnet -void palacios_print(const char *fmt, ...); +// This is how a component finds the proc dir we are using for global state +struct proc_dir_entry *palacios_get_procdir(void); + +// Selected exported stubs, for use in other palacios components, like vnet +// The idea is that everything uses the same stubs +void palacios_print(const char *fmt, ...); +void *palacios_allocate_pages(int num_pages, unsigned int alignment); +void palacios_free_pages(void *page_addr, int num_pages); +void *palacios_alloc(unsigned int size); +void palacios_free(void *); +void *palacios_vaddr_to_paddr(void *vaddr); +void *palacios_paddr_to_vaddr(void *paddr); +void *palacios_start_kernel_thread(int (*fn)(void * arg), void *arg, char *thread_name); +void *palacios_start_thread_on_cpu(int cpu_id, int (*fn)(void * arg), void *arg, char *thread_name); +int palacios_move_thread_to_cpu(int new_cpu_id, void *thread_ptr); +void palacios_yield_cpu(void); +void palacios_yield_cpu_timed(unsigned int us); unsigned int palacios_get_cpu(void); +unsigned int palacios_get_cpu_khz(void); +void *palacios_mutex_alloc(void); +void palacios_mutex_free(void *mutex); +void palacios_mutex_lock(void *mutex, int must_spin); +void palacios_mutex_unlock(void *mutex); +void *palacios_mutex_lock_irqsave(void *mutex, int must_spin); +void palacios_mutex_unlock_irqrestore(void *mutex, void *flags);