X-Git-Url: http://v3vee.org/palacios/gitweb/gitweb.cgi?a=blobdiff_plain;f=linux_module%2Fpalacios-stubs.c;h=ec58c04dd07865154c028101a6e7ad618a6740d5;hb=ea744834e3c756db65cdc211be929891cecafe09;hp=eea613b786ac0324714e248c1a94065e67a14d0f;hpb=8f7141b61d0c58befc5433a22d9af728fe3bb6f9;p=palacios.releases.git diff --git a/linux_module/palacios-stubs.c b/linux_module/palacios-stubs.c index eea613b..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; @@ -48,7 +54,7 @@ static void deinit_print_buffers(void) 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 @@ -135,7 +159,6 @@ void palacios_print(const char *fmt, ...) { } - /* * Allocates a contiguous region of pages of the requested size. * Returns the physical address of the first page in the region. @@ -144,6 +167,12 @@ 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; @@ -162,25 +191,44 @@ void palacios_free_pages(void * page_paddr, int 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. */ 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); - } - - if (addr) { - mallocs++; + return palacios_alloc_extended(size,GFP_KERNEL); } - return addr; } /** @@ -192,7 +240,7 @@ palacios_free( ) { frees++; - kfree(addr); + kfree(addr-ALLOC_PAD); return; } @@ -237,10 +285,13 @@ 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) { @@ -259,7 +310,7 @@ static int lnx_thread_target(void * arg) { INFO("Palacios Thread (%s) EXITING\n", thread_info->name); - kfree(thread_info); + palacios_free(thread_info); // handle cleanup do_exit(ret); @@ -276,13 +327,19 @@ palacios_start_kernel_thread( 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; - return kthread_run( lnx_thread_target, thread_info, thread_name ); + return kthread_run( lnx_thread_target, thread_info, thread_info->name ); } @@ -295,22 +352,30 @@ palacios_start_thread_on_cpu(int cpu_id, 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)) { - WARNING("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; } @@ -438,7 +503,8 @@ 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; @@ -461,7 +527,8 @@ palacios_hook_interrupt(struct v3_vm_info * vm, if (error) { ERROR("error code for request_irq is %d\n", error); - panic("request vector %d failed", vector); + ERROR("request vector %d failed", vector); + return -1; } } @@ -517,19 +584,25 @@ palacios_yield_cpu(void) * 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) +void palacios_sleep_cpu(unsigned int us) { - unsigned int uspj = 1000000U/HZ; - - unsigned int jiffies = us/uspj + ((us%uspj) !=0); // ceiling - set_current_state(TASK_INTERRUPTIBLE); - - schedule_timeout(jiffies); - + 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. @@ -538,10 +611,13 @@ void palacios_yield_cpu_timed(unsigned int us) 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; @@ -552,7 +628,7 @@ palacios_mutex_alloc(void) */ void palacios_mutex_free(void * mutex) { - kfree(mutex); + palacios_free(mutex); } /** @@ -591,7 +667,7 @@ palacios_mutex_unlock( /** - * Unlocks a mutex. + * Unlocks a mutex and restores previous interrupt state on this core */ void palacios_mutex_unlock_irqrestore(void *mutex, void *flags) @@ -604,7 +680,7 @@ palacios_mutex_unlock_irqrestore(void *mutex, void *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, @@ -616,7 +692,8 @@ 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, + .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, @@ -633,7 +710,7 @@ static struct v3_os_hooks palacios_os_hooks = { -int palacios_vmm_init( void ) +int palacios_vmm_init( char *options ) { int num_cpus = num_online_cpus(); char * cpu_mask = NULL; @@ -643,7 +720,7 @@ int palacios_vmm_init( void ) int minor = 0; int i = 0; - cpu_mask = kmalloc((num_cpus / 8) + 1, GFP_KERNEL); + cpu_mask = palacios_alloc((num_cpus / 8) + 1); if (!cpu_mask) { ERROR("Cannot allocate cpu mask\n"); @@ -669,13 +746,13 @@ int palacios_vmm_init( void ) if (init_print_buffers()) { ERROR("Cannot initialize print buffers\n"); - kfree(cpu_mask); + palacios_free(cpu_mask); return -1; } INFO("palacios_init starting - calling init_v3\n"); - Init_V3(&palacios_os_hooks, cpu_mask, num_cpus); + Init_V3(&palacios_os_hooks, cpu_mask, num_cpus, options); return 0;