X-Git-Url: http://v3vee.org/palacios/gitweb/gitweb.cgi?a=blobdiff_plain;f=linux_module%2Fpalacios-stubs.c;h=92b3767a303e9e05bc693b0e1f74b3ffcbdd1a77;hb=700ce14388ea852b7599b73b0d5a9f94fd873045;hp=60b481fc9ce99dd0b23a961c00c1dbfb29d06fd6;hpb=07aa8f3c18a33af0961e7546980a63ab5f6fba4f;p=palacios.git diff --git a/linux_module/palacios-stubs.c b/linux_module/palacios-stubs.c index 60b481f..92b3767 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; @@ -81,7 +87,7 @@ static int init_print_buffers(void) /** * Prints a message to the console. */ -void palacios_print(const char *fmt, ...) { +void palacios_print_scoped(void * vm, int vcore, const char *fmt, ...) { #if V3_PRINTK_OLD_STYLE_OUTPUT @@ -98,6 +104,7 @@ void palacios_print(const char *fmt, ...) { va_list ap; char *buf; unsigned int cpu = palacios_get_cpu(); + struct v3_guest *guest = (struct v3_guest *)vm; buf = print_buffer[cpu]; @@ -126,8 +133,25 @@ void palacios_print(const char *fmt, ...) { } #endif - printk(KERN_INFO "palacios (pcore %u): %s",cpu,buf); - + if (guest) { + if (vcore>=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. @@ -168,32 +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); + return palacios_alloc_extended(size,GFP_KERNEL); } - if (!addr) { - ERROR("ALERT ALERT kmalloc has FAILED FAILED FAILED\n"); - return NULL; - } - - mallocs++; - - return addr; } /** @@ -205,7 +240,7 @@ palacios_free( ) { frees++; - kfree(addr); + kfree(addr-ALLOC_PAD); return; } @@ -250,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) { @@ -298,9 +336,10 @@ palacios_start_kernel_thread( 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 ); } @@ -322,13 +361,13 @@ palacios_start_thread_on_cpu(int cpu_id, 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; } @@ -545,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. @@ -635,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, @@ -647,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,