#include <linux/uaccess.h>
#include <asm/irq_vectors.h>
#include <asm/io.h>
+#include <asm/thread_info.h>
#include <linux/init.h>
#include <linux/module.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
+// 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
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);
}
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;
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);
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;
}
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;
void palacios_vfree(void *p)
{
+ if (!p) {
+ ERROR("Ignoring vfree: 0x%p\n",p);
+ dump_stack();
+ return;
+ }
vfree(p);
vfrees++;
MEMCHECK_VFREE(p);
// 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);
if (!addr) {
ERROR("Ignoring free : 0x%p\n", addr);
dump_stack();
+ return;
}
frees++;
kfree(addr-ALLOC_PAD);
/**
* Runs a function on the specified CPU.
*/
-static void
+void
palacios_xcall(
int cpu_id,
void (*fn)(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) {
* 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 ) {
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;
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
struct thread_info *cur = current_thread_info();
// We assume we are not preemptible here...
- cur->status |= TS_USEDFPU;
+ cur->status |= 1;
clts();
// After this, FP Save should be handled by Linux if it
// switches to a different task and that task uses FPU
.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,
.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,
};
