static memory_cache_entry_t create_new_entry (vmi_instance_t vmi, addr_t paddr, uint32_t length)
{
// sanity check - are we getting memory outside of the physical memory range?
//
// This does not work with a Xen PV VM during page table lookups, because
// cr3 > [physical memory size]. It *might* not work when examining a PV
// snapshot, since we're not sure where the page tables end up. So, we
// just do it for a HVM guest.
//
// TODO: perform other reasonable checks
if (vmi->hvm && (paddr + length - 1 > vmi->size)) {
errprint ("--requesting PA [0x%llx] beyond memsize [0x%llx]\n",
paddr + length, vmi->size);
errprint ("\tpaddr: %llx, length %llx, vmi->size %llx\n",
paddr, length, vmi->size);
return 0;
}
memory_cache_entry_t entry =
(memory_cache_entry_t) safe_malloc(sizeof(struct memory_cache_entry));
entry->paddr = paddr;
entry->length = length;
entry->last_updated = time(NULL);
entry->last_used = entry->last_updated;
entry->data = get_memory_data(vmi, paddr, length);
if (vmi->memory_cache_size >= vmi->memory_cache_size_max){
clean_cache(vmi);
}
return entry;
}
void *
memory_cache_insert(
vmi_instance_t vmi,
addr_t paddr)
{
return get_memory_data(vmi, paddr, vmi->page_size);
}
void save_state() {
if (mem_state == NULL) {
mem_state = get_memory_data(0);
}
memcpy(mem_state, players, game_state_size());
detach_memory_data(mem_state);
}
char get_register_index(t_arena *arena, int address)
{
char rtn;
char *rtn_ptr;
rtn_ptr = get_memory_data(arena, address, 1);
rtn = *rtn_ptr;
free(rtn_ptr);
rtn--;
if (rtn < 0 || rtn >= REG_NUMBER)
rtn = 0;
return (rtn);
}
static void *validate_and_return_data (vmi_instance_t vmi, memory_cache_entry_t entry)
{
time_t now = time(NULL);
if (vmi->memory_cache_age && (now - entry->last_updated > vmi->memory_cache_age)){
dbprint("--MEMORY cache refresh 0x%llx\n", entry->paddr);
release_data_callback(entry->data, entry->length);
entry->data = get_memory_data(vmi, entry->paddr, entry->length);
entry->last_updated = now;
gint64 *key = safe_malloc(sizeof(gint64));
*key = entry->paddr;
vmi->memory_cache_lru = g_list_remove(vmi->memory_cache_lru, key);
vmi->memory_cache_lru = g_list_prepend(vmi->memory_cache_lru, key);
}
entry->last_used = now;
return entry->data;
}
t_list *process_routine(t_list *list, t_list *cur, void *param)
{
char *byte;
t_arena *arena;
t_process *proc;
arena = param;
proc = cur->data;
if (proc->cycles_left > 0)
proc->cycles_left--;
else
{
if (proc->cycles_left == 0)
call_asm_func(arena, proc);
byte = get_memory_data(arena, proc->pc, 1);
proc->cycles_left = get_op_info(*byte).nbr_cycles;
free(byte);
}
return (list);
}
static void *
validate_and_return_data(
vmi_instance_t vmi,
memory_cache_entry_t entry)
{
time_t now = time(NULL);
if (vmi->memory_cache_age &&
(now - entry->last_updated > vmi->memory_cache_age)) {
dbprint("--MEMORY cache refresh 0x%"PRIx64"\n", entry->paddr);
release_data_callback(entry->data, entry->length);
entry->data = get_memory_data(vmi, entry->paddr, entry->length);
entry->last_updated = now;
GList* lru_entry = g_list_find_custom(vmi->memory_cache_lru,
&entry->paddr, g_int64_equal);
vmi->memory_cache_lru = g_list_remove_link(vmi->memory_cache_lru,
lru_entry);
vmi->memory_cache_lru = g_list_concat(lru_entry, vmi->memory_cache_lru);
}
entry->last_used = now;
return entry->data;
}
void attach_state() {
mem_state = get_memory_data(0);
memcpy(players, mem_state, game_state_size());
}
