X-Git-Url: http://v3vee.org/palacios/gitweb/gitweb.cgi?a=blobdiff_plain;f=linux_module%2Fpalacios-stubs.c;h=a7f1607d779c5852eb69ddd3f03d7b0491618092;hb=07633e013ebc65d2680f0023b90094d9c3880186;hp=60b481fc9ce99dd0b23a961c00c1dbfb29d06fd6;hpb=07aa8f3c18a33af0961e7546980a63ab5f6fba4f;p=palacios.releases.git diff --git a/linux_module/palacios-stubs.c b/linux_module/palacios-stubs.c index 60b481f..a7f1607 100644 --- a/linux_module/palacios-stubs.c +++ b/linux_module/palacios-stubs.c @@ -14,22 +14,30 @@ #include #include #include +#include #include #include #include "palacios.h" +#include "mm.h" +#include "memcheck.h" +#include "lockcheck.h" - -#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; u32 mallocs = 0; u32 frees = 0; - +u32 vmallocs = 0; +u32 vfrees = 0; static struct v3_vm_info * irq_to_guest_map[256]; @@ -81,7 +89,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 +106,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 +135,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 +161,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. @@ -143,6 +168,11 @@ void palacios_print(const char *fmt, ...) { void *palacios_allocate_pages(int num_pages, unsigned int alignment) { void * pg_addr = NULL; + if (num_pages<=0) { + ERROR("ALERT ALERT Attempt to allocate zero or fewer pages\n"); + return NULL; + } + pg_addr = (void *)alloc_palacios_pgs(num_pages, alignment); if (!pg_addr) { @@ -152,6 +182,8 @@ void *palacios_allocate_pages(int num_pages, unsigned int alignment) { pg_allocs += num_pages; + MEMCHECK_ALLOC_PAGES(pg_addr,num_pages*4096); + return pg_addr; } @@ -165,8 +197,71 @@ void *palacios_allocate_pages(int num_pages, unsigned int alignment) { void palacios_free_pages(void * page_paddr, int num_pages) { pg_frees += num_pages; free_palacios_pgs((uintptr_t)page_paddr, num_pages); + MEMCHECK_FREE_PAGES(page_paddr,num_pages*4096); + +} + + +void * +palacios_alloc_extended(unsigned int size, unsigned int flags) { + void * addr = NULL; + + if (size==0) { + // note that modern kernels will respond to a zero byte + // kmalloc and return the address 0x10... In Palacios, + // we will simply not allow 0 byte allocs at all, of any kind + ERROR("ALERT ALERT attempt to kmalloc zero bytes rejected\n"); + return 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 + + MEMCHECK_KMALLOC(addr,size+2*ALLOC_PAD); + + return addr+ALLOC_PAD; +} + +void * +palacios_valloc(unsigned int size) +{ + void * addr = NULL; + + if (size==0) { + ERROR("ALERT ALERT attempt to vmalloc zero bytes rejected\n"); + return NULL; + } + + addr = vmalloc(size); + + if (!addr) { + ERROR("ALERT ALERT vmalloc has FAILED FAILED FAILED\n"); + return NULL; + } + + vmallocs++; + + MEMCHECK_VMALLOC(addr,size); + + return addr; } +void palacios_vfree(void *p) +{ + vfree(p); + vfrees++; + MEMCHECK_VFREE(p); +} /** * Allocates 'size' bytes of kernel memory. @@ -174,26 +269,17 @@ void palacios_free_pages(void * page_paddr, int num_pages) { */ 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,8 +291,8 @@ palacios_free( ) { frees++; - kfree(addr); - return; + kfree(addr-ALLOC_PAD); + MEMCHECK_KFREE(addr-ALLOC_PAD); } /** @@ -250,10 +336,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 +387,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 +412,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 +635,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. @@ -570,6 +666,7 @@ palacios_mutex_alloc(void) if (lock) { spin_lock_init(lock); + LOCKCHECK_ALLOC(lock); } else { ERROR("ALERT ALERT Unable to allocate lock\n"); return NULL; @@ -578,12 +675,35 @@ palacios_mutex_alloc(void) return lock; } +void palacios_mutex_init(void *mutex) +{ + spinlock_t *lock = (spinlock_t*)mutex; + + if (lock) { + spin_lock_init(lock); + LOCKCHECK_ALLOC(lock); + } +} + +void palacios_mutex_deinit(void *mutex) +{ + spinlock_t *lock = (spinlock_t*)mutex; + + if (lock) { + // no actual spin_lock_deinit on linux + // our purpose here is to drive the lock checker + LOCKCHECK_FREE(lock); + } +} + + /** * Frees a mutex. */ void palacios_mutex_free(void * mutex) { palacios_free(mutex); + LOCKCHECK_FREE(mutex); } /** @@ -591,7 +711,10 @@ palacios_mutex_free(void * mutex) { */ void palacios_mutex_lock(void * mutex, int must_spin) { + + LOCKCHECK_LOCK_PRE(mutex); spin_lock((spinlock_t *)mutex); + LOCKCHECK_LOCK_POST(mutex); } @@ -603,7 +726,9 @@ palacios_mutex_lock_irqsave(void * mutex, int must_spin) { unsigned long flags; + LOCKCHECK_LOCK_IRQSAVE_PRE(mutex,flags); spin_lock_irqsave((spinlock_t *)mutex,flags); + LOCKCHECK_LOCK_IRQSAVE_POST(mutex,flags); return (void *)flags; } @@ -617,7 +742,9 @@ palacios_mutex_unlock( void * mutex ) { + LOCKCHECK_UNLOCK_PRE(mutex); spin_unlock((spinlock_t *)mutex); + LOCKCHECK_UNLOCK_POST(mutex); } @@ -627,15 +754,17 @@ palacios_mutex_unlock( void palacios_mutex_unlock_irqrestore(void *mutex, void *flags) { + LOCKCHECK_UNLOCK_IRQRESTORE_PRE(mutex,(unsigned long)flags); // This is correct, flags is opaque spin_unlock_irqrestore((spinlock_t *)mutex,(unsigned long)flags); + LOCKCHECK_UNLOCK_IRQRESTORE_POST(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, @@ -647,7 +776,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, @@ -664,7 +794,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; @@ -706,7 +836,7 @@ int palacios_vmm_init( void ) 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;