X-Git-Url: http://v3vee.org/palacios/gitweb/gitweb.cgi?a=blobdiff_plain;f=linux_module%2Fpalacios-stubs.c;h=ec58c04dd07865154c028101a6e7ad618a6740d5;hb=298a05652b5704f9881af0683e3f16fc4cd03959;hp=36f7625916a2a69a445e43168085911715cce31c;hpb=a489c2ba0f26f4be1fa98d4af2c2bfa113c28dde;p=palacios.git diff --git a/linux_module/palacios-stubs.c b/linux_module/palacios-stubs.c index 36f7625..ec58c04 100644 --- a/linux_module/palacios-stubs.c +++ b/linux_module/palacios-stubs.c @@ -24,6 +24,12 @@ #include "mm.h" +// The following can be used to track heap bugs +// zero memory after allocation +#define ALLOC_ZERO_MEM 0 +// pad allocations by this many bytes on both ends of block +#define ALLOC_PAD 0 + u32 pg_allocs = 0; u32 pg_frees = 0; @@ -36,29 +42,137 @@ static struct v3_vm_info * irq_to_guest_map[256]; extern unsigned int cpu_khz; +extern int cpu_list[NR_CPUS]; +extern int cpu_list_len; + + +static char *print_buffer[NR_CPUS]; + +static void deinit_print_buffers(void) +{ + int i; + + for (i=0;i=0) { + printk(KERN_INFO "palacios (pcore %u vm %s vcore %u): %s", + cpu, + guest->name, + vcore, + buf); + } else { + printk(KERN_INFO "palacios (pcore %u vm %s): %s", + cpu, + guest->name, + buf); + } + } else { + printk(KERN_INFO "palacios (pcore %u): %s", + cpu, + buf); + } + return; -} +#endif + +} /* * Allocates a contiguous region of pages of the requested size. * Returns the physical address of the first page in the region. */ -static void * palacios_allocate_pages(int num_pages, unsigned int alignment) { +void *palacios_allocate_pages(int num_pages, unsigned int alignment) { void * pg_addr = NULL; pg_addr = (void *)alloc_palacios_pgs(num_pages, alignment); + + if (!pg_addr) { + ERROR("ALERT ALERT Page allocation has FAILED Warning\n"); + return NULL; + } + pg_allocs += num_pages; return pg_addr; @@ -71,48 +185,69 @@ static void * palacios_allocate_pages(int num_pages, unsigned int alignment) { * a single call while palacios_free_page() only frees a single page. */ -static void palacios_free_pages(void * page_paddr, int num_pages) { +void palacios_free_pages(void * page_paddr, int num_pages) { pg_frees += num_pages; free_palacios_pgs((uintptr_t)page_paddr, num_pages); } +void * +palacios_alloc_extended(unsigned int size, unsigned int flags) { + void * addr = NULL; + + addr = kmalloc(size+2*ALLOC_PAD, flags); + + if (!addr) { + ERROR("ALERT ALERT kmalloc has FAILED FAILED FAILED\n"); + return NULL; + } + + mallocs++; + +#if ALLOC_ZERO_MEM + memset(addr,0,size+2*ALLOC_PAD); +#endif + + return addr+ALLOC_PAD; +} + + /** * Allocates 'size' bytes of kernel memory. * Returns the kernel virtual address of the memory allocated. */ -static void * +void * palacios_alloc(unsigned int size) { - void * addr = NULL; + // It is very important that this test remains since + // this function is used extensively throughout palacios and the linux + // module, both in places where interrupts are off and where they are on + // a GFP_KERNEL call, when done with interrupts off can lead to DEADLOCK if (irqs_disabled()) { - addr = kmalloc(size, GFP_ATOMIC); + return palacios_alloc_extended(size,GFP_ATOMIC); } else { - addr = kmalloc(size, GFP_KERNEL); + return palacios_alloc_extended(size,GFP_KERNEL); } - mallocs++; - - return addr; } /** * Frees memory that was previously allocated by palacios_alloc(). */ -static void +void palacios_free( void * addr ) { frees++; - kfree(addr); + kfree(addr-ALLOC_PAD); return; } /** * Converts a kernel virtual address to the corresponding physical address. */ -static void * +void * palacios_vaddr_to_paddr( void * vaddr ) @@ -124,7 +259,7 @@ palacios_vaddr_to_paddr( /** * Converts a physical address to the corresponding kernel virtual address. */ -static void * +void * palacios_paddr_to_vaddr( void * paddr ) @@ -135,8 +270,6 @@ palacios_paddr_to_vaddr( /** * Runs a function on the specified CPU. */ - -// For now, do call only on local CPU static void palacios_xcall( int cpu_id, @@ -152,75 +285,100 @@ palacios_xcall( return; } + +#define MAX_THREAD_NAME 32 + struct lnx_thread_arg { int (*fn)(void * arg); void * arg; - char * name; + char name[MAX_THREAD_NAME]; }; static int lnx_thread_target(void * arg) { struct lnx_thread_arg * thread_info = (struct lnx_thread_arg *)arg; - + int ret = 0; /* - printk("Daemonizing new Palacios thread (name=%s)\n", thread_info->name); + INFO("Daemonizing new Palacios thread (name=%s)\n", thread_info->name); daemonize(thread_info->name); allow_signal(SIGKILL); */ - thread_info->fn(thread_info->arg); + ret = thread_info->fn(thread_info->arg); - kfree(thread_info); + + INFO("Palacios Thread (%s) EXITING\n", thread_info->name); + + palacios_free(thread_info); // handle cleanup + + do_exit(ret); - return 0; + return 0; // should not get here. } /** * Creates a kernel thread. */ -static void +void * palacios_start_kernel_thread( int (*fn) (void * arg), void * arg, char * thread_name) { - struct lnx_thread_arg * thread_info = kmalloc(sizeof(struct lnx_thread_arg), GFP_KERNEL); + struct lnx_thread_arg * thread_info = palacios_alloc(sizeof(struct lnx_thread_arg)); + + if (!thread_info) { + ERROR("ALERT ALERT Unable to allocate thread\n"); + return NULL; + } thread_info->fn = fn; thread_info->arg = arg; - thread_info->name = thread_name; + strncpy(thread_info->name,thread_name,MAX_THREAD_NAME); + thread_info->name[MAX_THREAD_NAME-1] =0; - kthread_run( lnx_thread_target, thread_info, thread_name ); - return; + return kthread_run( lnx_thread_target, thread_info, thread_info->name ); } /** * 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, char * thread_name ) { struct task_struct * thread = NULL; - struct lnx_thread_arg * thread_info = kmalloc(sizeof(struct lnx_thread_arg), GFP_KERNEL); + struct lnx_thread_arg * thread_info = palacios_alloc(sizeof(struct lnx_thread_arg)); + + if (!thread_info) { + ERROR("ALERT ALERT Unable to allocate thread to start on cpu\n"); + return NULL; + } thread_info->fn = fn; thread_info->arg = arg; - thread_info->name = thread_name; - + strncpy(thread_info->name,thread_name,MAX_THREAD_NAME); + thread_info->name[MAX_THREAD_NAME-1] =0; - thread = kthread_create( lnx_thread_target, thread_info, thread_name ); + thread = kthread_create( lnx_thread_target, thread_info, thread_info->name ); if (IS_ERR(thread)) { - printk("Palacios error creating thread: %s\n", thread_name); + WARNING("Palacios error creating thread: %s\n", thread_info->name); + palacios_free(thread_info); + return NULL; + } + + if (set_cpus_allowed_ptr(thread, cpumask_of(cpu_id)) != 0) { + WARNING("Attempt to start thread on disallowed CPU\n"); + kthread_stop(thread); + palacios_free(thread_info); return NULL; } - kthread_bind(thread, cpu_id); wake_up_process(thread); return thread; @@ -232,12 +390,14 @@ 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) { + void * thread_ptr) { struct task_struct * thread = (struct task_struct *)thread_ptr; - if(thread == NULL){ + INFO("Moving thread (%p) to cpu %d\n", thread, new_cpu_id); + + if (thread == NULL) { thread = current; } @@ -245,14 +405,14 @@ palacios_move_thread_to_cpu(int new_cpu_id, * Bind to the specified CPU. When this call returns, * the thread should be running on the target CPU. */ - return set_cpus_allowed(thread, cpumask_of_cpu(new_cpu_id)); + return set_cpus_allowed_ptr(thread, cpumask_of(new_cpu_id)); } /** * Returns the CPU ID that the caller is running on. */ -static unsigned int +unsigned int palacios_get_cpu(void) { @@ -318,16 +478,16 @@ palacios_dispatch_interrupt( int vector, void * dev, struct pt_regs * regs ) { static int palacios_hook_interrupt(struct v3_vm_info * vm, unsigned int vector ) { - printk("hooking vector %d\n", vector); + INFO("hooking vector %d\n", vector); if (irq_to_guest_map[vector]) { - printk(KERN_WARNING + WARNING( "%s: Interrupt vector %u is already hooked.\n", __func__, vector); return -1; } - printk(KERN_DEBUG + DEBUG( "%s: Hooking interrupt vector %u to vm %p.\n", __func__, vector, vm); @@ -343,14 +503,15 @@ palacios_hook_interrupt(struct v3_vm_info * vm, //set_idtvec_handler(vector, palacios_dispatch_interrupt); if (vector < 32) { - panic("unexpected vector for hooking\n"); + ERROR("unexpected vector for hooking\n"); + return -1; } else { int device_id = 0; int flag = 0; int error; - printk("hooking vector: %d\n", vector); + DEBUG("hooking vector: %d\n", vector); if (vector == 32) { flag = IRQF_TIMER; @@ -365,8 +526,9 @@ palacios_hook_interrupt(struct v3_vm_info * vm, &device_id); if (error) { - printk("error code for request_irq is %d\n", error); - panic("request vector %d failed",vector); + ERROR("error code for request_irq is %d\n", error); + ERROR("request vector %d failed", vector); + return -1; } } @@ -384,20 +546,20 @@ palacios_ack_interrupt( ) { ack_APIC_irq(); - printk("Pretending to ack interrupt, vector=%d\n",vector); + DEBUG("Pretending to ack interrupt, vector=%d\n", vector); return 0; } /** * Returns the CPU frequency in kilohertz. */ -static unsigned int +unsigned int palacios_get_cpu_khz(void) { - printk("cpu_khz is %u\n",cpu_khz); + INFO("cpu_khz is %u\n", cpu_khz); if (cpu_khz == 0) { - printk("faking cpu_khz to 1000000\n"); + INFO("faking cpu_khz to 1000000\n"); return 1000000; } else { return cpu_khz; @@ -407,27 +569,55 @@ 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_sleep_cpu(unsigned int us) +{ + + set_current_state(TASK_INTERRUPTIBLE); + if (us) { + unsigned int uspj = 1000000U/HZ; + unsigned int jiffies = us/uspj + ((us%uspj) !=0); // ceiling + schedule_timeout(jiffies); + } else { + schedule(); + } + return; +} +void palacios_wakeup_cpu(void *thread) +{ + wake_up_process(thread); + return; +} /** * Allocates a mutex. * Returns NULL on failure. */ -static void * +void * palacios_mutex_alloc(void) { - spinlock_t *lock = kmalloc(sizeof(spinlock_t), GFP_KERNEL); + spinlock_t *lock = palacios_alloc(sizeof(spinlock_t)); if (lock) { spin_lock_init(lock); + } else { + ERROR("ALERT ALERT Unable to allocate lock\n"); + return NULL; } return lock; @@ -436,23 +626,38 @@ palacios_mutex_alloc(void) /** * Frees a mutex. */ -static void +void palacios_mutex_free(void * mutex) { - kfree(mutex); + palacios_free(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 ) @@ -460,11 +665,22 @@ palacios_mutex_unlock( spin_unlock((spinlock_t *)mutex); } + +/** + * Unlocks a mutex and restores previous interrupt state on this core + */ +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. */ static struct v3_os_hooks palacios_os_hooks = { - .print = palacios_print, + .print = palacios_print_scoped, .allocate_pages = palacios_allocate_pages, .free_pages = palacios_free_pages, .malloc = palacios_alloc, @@ -476,28 +692,67 @@ 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, + .sleep_cpu = palacios_sleep_cpu, + .wakeup_cpu = palacios_wakeup_cpu, .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, .start_thread_on_cpu = palacios_start_thread_on_cpu, - .move_thread_to_cpu = palacios_move_thread_to_cpu, + .move_thread_to_cpu = palacios_move_thread_to_cpu, }; -int palacios_vmm_init( void ) +int palacios_vmm_init( char *options ) { + int num_cpus = num_online_cpus(); + char * cpu_mask = NULL; + + if (cpu_list_len > 0) { + int major = 0; + int minor = 0; + int i = 0; + + cpu_mask = palacios_alloc((num_cpus / 8) + 1); + + if (!cpu_mask) { + ERROR("Cannot allocate cpu mask\n"); + return -1; + } + + memset(cpu_mask, 0, (num_cpus / 8) + 1); + + for (i = 0; i < cpu_list_len; i++) { + if (cpu_list[i] >= num_cpus) { + WARNING("CPU (%d) exceeds number of available CPUs. Ignoring...\n", cpu_list[i]); + continue; + } + + major = cpu_list[i] / 8; + minor = cpu_list[i] % 8; + *(cpu_mask + major) |= (0x1 << minor); + } + } + memset(irq_to_guest_map, 0, sizeof(struct v3_vm_info *) * 256); - - printk("palacios_init starting - calling init_v3\n"); - - Init_V3(&palacios_os_hooks, num_online_cpus()); + + if (init_print_buffers()) { + ERROR("Cannot initialize print buffers\n"); + palacios_free(cpu_mask); + return -1; + } + + INFO("palacios_init starting - calling init_v3\n"); + + Init_V3(&palacios_os_hooks, cpu_mask, num_cpus, options); return 0; @@ -508,5 +763,9 @@ int palacios_vmm_exit( void ) { Shutdown_V3(); + INFO("palacios shutdown complete\n"); + + deinit_print_buffers(); + return 0; }