#include <linux/uaccess.h>
#include <asm/irq_vectors.h>
#include <asm/io.h>
+#include <asm/thread_info.h>
+#include <asm/i387.h>
+#include <linux/version.h>
+#if LINUX_VERSION_CODE >= KERNEL_VERSION(3,7,0)
+#include <asm/fpu-internal.h>
+#endif
#include <linux/init.h>
#include <linux/module.h>
#include "palacios.h"
+#include "util-hashtable.h"
+
#include "mm.h"
#include "memcheck.h"
extern int cpu_list_len;
+extern struct hashtable *v3_thread_resource_map;
+
+
static char *print_buffer[NR_CPUS];
static void deinit_print_buffers(void)
* 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;
+ v3_resource_control_t *r;
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);
+ if ((r=(v3_resource_control_t *)palacios_htable_search(v3_thread_resource_map,(addr_t)current))) {
+ // thread has a registered resource control structure
+ // these override any default values
+ // INFO("Overridden page search: (pre) alignment=%x, node_id=%x, filter_func=%p, filter_state=%p\n",alignment,node_id,filter_func,filter_state);
+ if (alignment==4096) {
+ alignment = r->pg_alignment;
+ }
+ if (node_id==-1) {
+ node_id = r->pg_node_id;
+ }
+ if (!filter_func) {
+ filter_func = r->pg_filter_func;
+ filter_state = r->pg_filter_state;
+ }
+ //INFO("Overridden page search: (post) alignment=%x, node_id=%x, filter_func=%p, filter_state=%p\n",alignment,node_id,filter_func,filter_state);
+ }
+
+ 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;
}
// 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);
/**
* Runs a function on the specified CPU.
*/
-static void
+void
palacios_xcall(
int cpu_id,
void (*fn)(void *arg),
struct lnx_thread_arg {
int (*fn)(void * arg);
void * arg;
+ v3_resource_control_t *resource_control;
char name[MAX_THREAD_NAME];
};
// We are a kernel thread that needs FPU save/restore state
// vcores definitely need this, all the other threads get it too,
// but they just won't use it
+
fpu_alloc(&(current->thread.fpu));
#endif
+ palacios_htable_insert(v3_thread_resource_map,(addr_t)current,(addr_t)thread_info->resource_control);
+
ret = thread_info->fn(thread_info->arg);
INFO("Palacios Thread (%s) EXITING\n", thread_info->name);
+ palacios_htable_remove(v3_thread_resource_map,(addr_t)current,0);
+
palacios_free(thread_info);
// handle cleanup
palacios_create_and_start_kernel_thread(
int (*fn) (void * arg),
void * arg,
- char * thread_name) {
+ char * thread_name,
+ v3_resource_control_t *resource_control) {
struct lnx_thread_arg * thread_info = palacios_alloc(sizeof(struct lnx_thread_arg));
thread_info->arg = arg;
strncpy(thread_info->name,thread_name,MAX_THREAD_NAME);
thread_info->name[MAX_THREAD_NAME-1] =0;
+ thread_info->resource_control = resource_control;
return kthread_run( lnx_thread_target, thread_info, thread_info->name );
}
*/
void *
palacios_create_thread_on_cpu(int cpu_id,
- int (*fn)(void * arg),
- void * arg,
- char * thread_name ) {
+ int (*fn)(void * arg),
+ void * arg,
+ char * thread_name,
+ v3_resource_control_t *resource_control) {
struct task_struct * thread = NULL;
struct lnx_thread_arg * thread_info = palacios_alloc(sizeof(struct lnx_thread_arg));
thread_info->arg = arg;
strncpy(thread_info->name,thread_name,MAX_THREAD_NAME);
thread_info->name[MAX_THREAD_NAME-1] =0;
+ thread_info->resource_control=resource_control;
thread = kthread_create( lnx_thread_target, thread_info, thread_info->name );
palacios_create_and_start_thread_on_cpu(int cpu_id,
int (*fn)(void * arg),
void * arg,
- char * thread_name ) {
+ char * thread_name,
+ v3_resource_control_t *resource_control) {
- void *t = palacios_create_thread_on_cpu(cpu_id, fn, arg, thread_name);
+ void *t = palacios_create_thread_on_cpu(cpu_id, fn, arg, thread_name, resource_control);
if (t) {
palacios_start_thread(t);
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
.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,