X-Git-Url: http://v3vee.org/palacios/gitweb/gitweb.cgi?a=blobdiff_plain;f=linux_module%2Fpalacios-stubs.c;h=10d2fdec858b466f681f5b865b803e4d4559d84e;hb=b58fe2254858e3ecc94be5d86f2a93f2cfe0a0d5;hp=decae1f653433f67d8e816eae83bdc86faf0d51f;hpb=9feccf93cd8327d1d30a404a92f19716bf5a1e96;p=palacios.git diff --git a/linux_module/palacios-stubs.c b/linux_module/palacios-stubs.c index decae1f..10d2fde 100644 --- a/linux_module/palacios-stubs.c +++ b/linux_module/palacios-stubs.c @@ -8,6 +8,7 @@ #include #include #include +#include #include #include @@ -34,10 +35,10 @@ -// 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 +// The following can be used to track memory bugs +// zero memory after allocation (now applies to valloc and page alloc as well) +#define ALLOC_ZERO_MEM 1 +// pad allocations by this many bytes on both ends of block (heap only) #define ALLOC_PAD 0 @@ -84,7 +85,7 @@ static int init_print_buffers(void) if (!print_buffer[i]) { ERROR("Cannot allocate print buffer for cpu %d\n",i); deinit_print_buffers(); - return -1; + return -1; } memset(print_buffer[i],0,V3_PRINTK_BUF_SIZE); } @@ -174,23 +175,27 @@ void palacios_print_scoped(void * vm, int vcore, const char *fmt, ...) { * Allocates a contiguous region of pages of the requested size. * Returns the physical address of the first page in the region. */ -void *palacios_allocate_pages(int num_pages, unsigned int alignment, int node_id, int constraints) { +void *palacios_allocate_pages(int num_pages, unsigned int alignment, int node_id, int (*filter_func)(void *paddr, void *filter_state), void *filter_state) { void * pg_addr = NULL; if (num_pages<=0) { - ERROR("ALERT ALERT Attempt to allocate zero or fewer pages (%d pages, alignment %d, node %d, constraints 0x%x)\n",num_pages, alignment, node_id, constraints); + ERROR("ALERT ALERT Attempt to allocate zero or fewer pages (%d pages, alignment %d, node %d, filter_func %p, filter_state %p)\n",num_pages, alignment, node_id, filter_func, filter_state); return NULL; } - pg_addr = (void *)alloc_palacios_pgs(num_pages, alignment, node_id, constraints); + pg_addr = (void *)alloc_palacios_pgs(num_pages, alignment, node_id, filter_func, filter_state); if (!pg_addr) { - ERROR("ALERT ALERT Page allocation has FAILED Warning (%d pages, alignment %d, node %d, constraints 0x%x)\n",num_pages, alignment, node_id, constraints); + ERROR("ALERT ALERT Page allocation has FAILED Warning (%d pages, alignment %d, node %d, filter_func %p, filter_state %p)\n",num_pages, alignment, node_id, filter_func, filter_state); return NULL; } pg_allocs += num_pages; +#if ALLOC_ZERO_MEM + memset(__va(pg_addr),0,num_pages*4096); +#endif + MEMCHECK_ALLOC_PAGES(pg_addr,num_pages*4096); return pg_addr; @@ -207,6 +212,7 @@ void palacios_free_pages(void * page_paddr, int num_pages) { if (!page_paddr) { ERROR("Ignoring free pages: 0x%p (0x%lx)for %d pages\n", page_paddr, (uintptr_t)page_paddr, num_pages); dump_stack(); + return; } pg_frees += num_pages; free_palacios_pgs((uintptr_t)page_paddr, num_pages); @@ -233,7 +239,7 @@ palacios_alloc_extended(unsigned int size, unsigned int flags, int node) { addr = kmalloc_node(size+2*ALLOC_PAD, flags, node); } - if (!addr) { + if (!addr || IS_ERR(addr)) { ERROR("ALERT ALERT kmalloc has FAILED FAILED FAILED\n"); return NULL; } @@ -261,13 +267,17 @@ palacios_valloc(unsigned int size) addr = vmalloc(size); - if (!addr) { + if (!addr || IS_ERR(addr)) { ERROR("ALERT ALERT vmalloc has FAILED FAILED FAILED\n"); return NULL; } vmallocs++; +#if ALLOC_ZERO_MEM + memset(addr,0,size); +#endif + MEMCHECK_VMALLOC(addr,size); return addr; @@ -275,6 +285,11 @@ palacios_valloc(unsigned int size) void palacios_vfree(void *p) { + if (!p) { + ERROR("Ignoring vfree: 0x%p\n",p); + dump_stack(); + return; + } vfree(p); vfrees++; MEMCHECK_VFREE(p); @@ -291,7 +306,7 @@ palacios_alloc(unsigned int size) { // 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()) { + if (irqs_disabled() || in_atomic()) { return palacios_alloc_extended(size,GFP_ATOMIC,-1); } else { return palacios_alloc_extended(size,GFP_KERNEL,-1); @@ -310,6 +325,7 @@ palacios_free( if (!addr) { ERROR("Ignoring free : 0x%p\n", addr); dump_stack(); + return; } frees++; kfree(addr-ALLOC_PAD); @@ -342,7 +358,7 @@ palacios_paddr_to_vaddr( /** * Runs a function on the specified CPU. */ -static void +void palacios_xcall( int cpu_id, void (*fn)(void *arg), @@ -402,7 +418,7 @@ static int lnx_thread_target(void * arg) { * Creates a kernel thread. */ void * -palacios_start_kernel_thread( +palacios_create_and_start_kernel_thread( int (*fn) (void * arg), void * arg, char * thread_name) { @@ -427,7 +443,7 @@ palacios_start_kernel_thread( * Starts a kernel thread on the specified CPU. */ void * -palacios_start_thread_on_cpu(int cpu_id, +palacios_create_thread_on_cpu(int cpu_id, int (*fn)(void * arg), void * arg, char * thread_name ) { @@ -446,7 +462,7 @@ palacios_start_thread_on_cpu(int cpu_id, thread = kthread_create( lnx_thread_target, thread_info, thread_info->name ); - if (IS_ERR(thread)) { + if (!thread || IS_ERR(thread)) { WARNING("Palacios error creating thread: %s\n", thread_info->name); palacios_free(thread_info); return NULL; @@ -459,11 +475,36 @@ palacios_start_thread_on_cpu(int cpu_id, return NULL; } - wake_up_process(thread); - return thread; } +void +palacios_start_thread(void * th){ + + struct task_struct * thread = (struct task_struct *)th; + wake_up_process(thread); + +} + +/* + Convenience wrapper +*/ +void * +palacios_create_and_start_thread_on_cpu(int cpu_id, + int (*fn)(void * arg), + void * arg, + char * thread_name ) { + + void *t = palacios_create_thread_on_cpu(cpu_id, fn, arg, thread_name); + + if (t) { + palacios_start_thread(t); + } + + return t; +} + + /** * Rebind a kernel thread to the specified CPU @@ -791,10 +832,14 @@ palacios_mutex_unlock_irqrestore(void *mutex, void *flags) void palacios_used_fpu(void) { - struct thread_info *cur = current_thread_info(); - // We assume we are not preemptible here... - cur->status |= TS_USEDFPU; +#ifndef TS_USEDFPU + struct task_struct *tsk = current; + tsk->thread.fpu.has_fpu = 1; +#else + struct thread_info *cur = current_thread_info(); + cur->status |= TS_USEDFPU; +#endif clts(); // After this, FP Save should be handled by Linux if it // switches to a different task and that task uses FPU @@ -823,6 +868,8 @@ static struct v3_os_hooks palacios_os_hooks = { .print = palacios_print_scoped, .allocate_pages = palacios_allocate_pages, .free_pages = palacios_free_pages, + .vmalloc = palacios_valloc, + .vfree = palacios_vfree, .malloc = palacios_alloc, .free = palacios_free, .vaddr_to_paddr = palacios_vaddr_to_paddr, @@ -830,7 +877,7 @@ static struct v3_os_hooks palacios_os_hooks = { .hook_interrupt = palacios_hook_interrupt, .ack_irq = palacios_ack_interrupt, .get_cpu_khz = palacios_get_cpu_khz, - .start_kernel_thread = palacios_start_kernel_thread, + .start_kernel_thread = palacios_create_and_start_kernel_thread, .yield_cpu = palacios_yield_cpu, .sleep_cpu = palacios_sleep_cpu, .wakeup_cpu = palacios_wakeup_cpu, @@ -843,7 +890,8 @@ static struct v3_os_hooks palacios_os_hooks = { .get_cpu = palacios_get_cpu, .interrupt_cpu = palacios_interrupt_cpu, .call_on_cpu = palacios_xcall, - .start_thread_on_cpu = palacios_start_thread_on_cpu, + .create_thread_on_cpu = palacios_create_thread_on_cpu, + .start_thread = palacios_start_thread, .move_thread_to_cpu = palacios_move_thread_to_cpu, };